[gnome-devel-docs] Updated Greek translation

[Dimitris Spingos <dimspingos src gnome org>]

commit c8a47a693e87467771e84193ce145e4b88676f84
Author: Dimitris Spingos <dmtrs32 gmail com>
Date:   Tue Jun 19 16:11:16 2012 +0300

    Updated Greek translation

 platform-demos/el/el.po |10711 +++++++++++++++++++++++++++++++++++++++++++----
 1 files changed, 9890 insertions(+), 821 deletions(-)
---
diff --git a/platform-demos/el/el.po b/platform-demos/el/el.po
index 1cb01bd..b40ad2b 100644
--- a/platform-demos/el/el.po
+++ b/platform-demos/el/el.po
@@ -1,1138 +1,10207 @@
 # 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.
 # Simos Xenitellis <simos gnome org>, 2011.
-#
+# Dimitris Spingos (ÎÎÎÎÏÏÎÏ ÎÏÎÎÎÎÏ) <dmtrs32 gmail com>, 2012.
 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 15:42+0200\n"
-"Last-Translator: Simos Xenitellis <simos gnome org>\n"
-"Language-Team: Greek <team gnome gr>\n"
+"POT-Creation-Date: 2012-05-31 21:30+0000\n"
+"PO-Revision-Date: 2012-06-19 15:18+0300\n"
+"Last-Translator: Dimitris Spingos (ÎÎÎÎÏÏÎÏ ÎÏÎÎÎÎÏ) <dmtrs32 gmail com>\n"
+"Language-Team: team gnome gr\n"
+"Language: el\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\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"
-
-msgid "Johannes Schmid"
-msgstr "Johannes Schmid"
-
-msgid "jhs gnome org"
-msgstr "jhs gnome org"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Generator: Virtaal 0.7.0\n"
+"X-Project-Style: gnome\n"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/window.vala.page:23(None) C/window.py.page:24(None)
+#: C/window.js.page:23(None) C/window.c.page:23(None)
+#: C/GtkApplicationWindow.vala.page:20(None)
+#: C/GtkApplicationWindow.py.page:20(None)
+#: C/GtkApplicationWindow.js.page:20(None)
+#: C/GtkApplicationWindow.c.page:20(None)
+msgid "@@image: 'media/window.png'; md5=eb0cde3530978619c25bddfaeb453345"
+msgstr "@@image: 'media/window.png'Â md5=eb0cde3530978619c25bddfaeb453345"
+
+#: C/window.vala.page:11(name) C/window.py.page:11(name)
+#: C/window.c.page:11(name) C/vala.page:10(name) C/translate.page:10(name)
+#: C/treeview_simple_liststore.vala.page:13(name) C/toolbar.vala.page:12(name)
+#: C/toolbar.js.page:11(name) C/togglebutton.vala.page:14(name)
+#: C/switch.vala.page:15(name) C/statusbar.vala.page:14(name)
+#: C/spinner.vala.page:11(name) C/radiobutton.vala.page:14(name)
+#: C/py.page:10(name) C/progressbar.vala.page:11(name)
+#: C/messagedialog.vala.page:11(name) C/label.vala.page:11(name)
+#: C/js.page:11(name) C/index.page:22(name) C/image-viewer.vala.page:25(name)
+#: C/image.vala.page:11(name) C/guitar-tuner.vala.page:21(name)
+#: C/GtkApplicationWindow.vala.page:11(name)
+#: C/GtkApplicationWindow.py.page:11(name)
+#: C/GtkApplicationWindow.js.page:11(name)
+#: C/GtkApplicationWindow.c.page:11(name) C/grid.vala.page:13(name)
+#: C/grid.py.page:11(name) C/gmenu.vala.page:17(name) C/gmenu.py.page:11(name)
+#: C/gmenu.js.page:11(name) C/gmenu.c.page:11(name) C/entry.vala.page:11(name)
+#: C/documentation.page:10(name) C/dialog.vala.page:11(name)
+#: C/cpp.page:10(name) C/combobox.vala.page:11(name)
+#: C/checkbutton.vala.page:11(name) C/checkbutton.c.page:11(name)
+#: C/c.page:10(name) C/button.vala.page:11(name) C/bug-filing.page:9(name)
+#: C/beginner.vala.page:13(name) C/beginner.py.page:13(name)
+#: C/aboutdialog.vala.page:17(name)
+msgid "Tiffany Antopolski"
+msgstr "Tiffany Antopolski"
+
+#: C/window.vala.page:12(email) C/window.py.page:12(email)
+#: C/window.c.page:12(email) C/vala.page:11(email) C/translate.page:11(email)
+#: C/treeview_simple_liststore.vala.page:14(email)
+#: C/toolbar.vala.page:13(email) C/toolbar.js.page:12(email)
+#: C/togglebutton.vala.page:15(email) C/switch.vala.page:16(email)
+#: C/statusbar.vala.page:15(email) C/spinner.vala.page:12(email)
+#: C/radiobutton.vala.page:15(email) C/py.page:11(email)
+#: C/progressbar.vala.page:12(email) C/messagedialog.vala.page:12(email)
+#: C/label.vala.page:12(email) C/js.page:12(email) C/index.page:23(email)
+#: C/image-viewer.vala.page:26(email) C/image.vala.page:12(email)
+#: C/guitar-tuner.vala.page:22(email)
+#: C/GtkApplicationWindow.vala.page:12(email)
+#: C/GtkApplicationWindow.py.page:12(email)
+#: C/GtkApplicationWindow.js.page:12(email)
+#: C/GtkApplicationWindow.c.page:12(email) C/grid.vala.page:14(email)
+#: C/grid.py.page:12(email) C/gmenu.vala.page:18(email)
+#: C/gmenu.py.page:12(email) C/gmenu.js.page:12(email)
+#: C/gmenu.c.page:12(email) C/entry.vala.page:12(email)
+#: C/documentation.page:11(email) C/dialog.vala.page:12(email)
+#: C/cpp.page:11(email) C/combobox.vala.page:12(email)
+#: C/checkbutton.vala.page:12(email) C/c.page:11(email)
+#: C/button.vala.page:12(email) C/beginner.vala.page:14(email)
+#: C/beginner.py.page:14(email) C/aboutdialog.vala.page:18(email)
+msgid "tiffany antopolski gmail com"
+msgstr "tiffany antopolski gmail com"
+
+#: C/window.vala.page:13(years) C/window.py.page:13(years)
+#: C/window.js.page:13(years) C/window.c.page:13(years)
+#: C/weatherGeonames.js.page:12(years) C/weatherAutotools.js.page:12(years)
+#: C/weatherAppMain.js.page:12(years) C/weatherApp.js.page:12(years)
+#: C/treeview_simple_liststore.vala.page:15(years)
+#: C/toolbar.vala.page:14(years) C/toolbar.js.page:13(years)
+#: C/togglebutton.vala.page:16(years) C/togglebutton.py.page:15(years)
+#: C/textview.py.page:14(years) C/switch.vala.page:17(years)
+#: C/switch.py.page:17(years) C/statusbar.vala.page:16(years)
+#: C/statusbar.py.page:16(years) C/spinner.vala.page:13(years)
+#: C/spinner.py.page:13(years) C/spinbutton.py.page:14(years)
+#: C/scrolledwindow.py.page:13(years) C/scale.py.page:14(years)
+#: C/radiobutton.vala.page:16(years) C/radiobutton.py.page:16(years)
+#: C/progressbar.vala.page:13(years) C/progressbar.py.page:13(years)
+#: C/messagedialog.vala.page:13(years) C/messagedialog.py.page:13(years)
+#: C/messagedialog.js.page:13(years) C/linkbutton.py.page:13(years)
+#: C/linkbutton.js.page:13(years) C/label.vala.page:13(years)
+#: C/label.py.page:13(years) C/label.js.page:13(years)
+#: C/label.c.page:13(years) C/image.vala.page:13(years)
+#: C/image.py.page:13(years) C/image.c.page:13(years)
+#: C/helloworldautotools.js.page:12(years) C/helloWorld.js.page:12(years)
+#: C/guitar-tuner.js.page:12(years) C/GtkApplicationWindow.vala.page:13(years)
+#: C/GtkApplicationWindow.py.page:13(years)
+#: C/GtkApplicationWindow.js.page:13(years)
+#: C/GtkApplicationWindow.c.page:13(years) C/grid.vala.page:15(years)
+#: C/grid.py.page:13(years) C/grid.js.page:13(years)
+#: C/gmenu.vala.page:13(years) C/gmenu.py.page:13(years)
+#: C/gmenu.js.page:13(years) C/gmenu.c.page:13(years)
+#: C/entry.vala.page:13(years) C/entry.py.page:13(years)
+#: C/dialog.vala.page:13(years) C/dialog.py.page:13(years)
+#: C/dialog.js.page:13(years) C/desktop.js.page:12(years)
+#: C/combobox.vala.page:13(years) C/checkbutton.vala.page:13(years)
+#: C/checkbutton.py.page:13(years) C/checkbutton.c.page:13(years)
+#: C/button.vala.page:13(years) C/button.py.page:13(years)
+#: C/button.js.page:13(years) C/beginner.js.page:12(years)
+#: C/aboutdialog.vala.page:13(years) C/aboutdialog.py.page:13(years)
+#: C/aboutdialog.js.page:12(years)
+msgid "2012"
+msgstr "2012"
+
+#: C/window.vala.page:16(desc) C/window.py.page:16(desc)
+#: C/window.c.page:16(desc)
+msgid "A toplevel window which can contain other widgets"
+msgstr ""
+"ÎÎÎ ÏÎÏÎÎÏÏÎ ÎÎÏÏÎÏÎÏ ÎÏÎÏÎÎÎÏ ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ"
 
-msgid "GNOME Documentation Project"
-msgstr "ÎÏÎÎ ÏÎÎÎÎÏÎÏÏÎÏ GNOME"
+#: C/window.vala.page:19(title) C/window.py.page:19(title)
+#: C/window.js.page:19(title) C/window.c.page:19(title)
+msgid "Window"
+msgstr "ÎÎÏÎÎÏÏÎ"
 
-msgid "Create a project in Anjuta"
-msgstr "ÎÎÎÎÎÏÏÎÎÏÏÎ ÎÎÎ ÎÏÎÎ ÎÎ ÏÎ Anjuta"
+#: C/window.vala.page:24(p)
+#| msgid "A first Gtk application"
+msgid "The simplest Gtk.Application"
+msgstr "ÎÎÎ ÎÏÎÎÏÏÏÎÏÎ ÎÏÎÏÎÎÎÎ ÏÎ Gtk"
 
+#: C/window.vala.page:27(p)
 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."
+"Use <link xref=\"GtkApplicationWindow.vala\">Application Window</link> if "
+"you need GMenu support."
 msgstr ""
-"ÎÏÎÎ ÎÎÎÎÎÎÏÎÏÎ ÎÎ ÏÏÎÎÏÎÎÎÎÏÎÎÎÏÎ, ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎ ÎÎÎÎÎÏÏÎÎÎ "
-"ÎÏÎÎ ÏÏÎ Anjuta. ÎÏÏÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÏÎ ÏÎÎ ÏÎ ÎÏÎÏÎÎÏÎÏÎ ÎÏÏÎÎÎ ÏÎÏ "
-"ÏÏÎÎÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎ ÎÏÎÏÏÎÏÎ. ÎÏÎÏÎÏ ÎÎ ÎÏÎÎ ÏÏÎÏÎÎÎ ÎÎ "
-"ÏÎ ÎÏÎÏÎÏÎ ÏÎÎ ÎÎÎÎ."
-
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ <link xref=\"GtkApplicationWindow.vala\">ÏÎÏÎÎÏÏÎ "
+"ÎÏÎÏÎÎÎÎÏ</link> ÎÎÎ ÏÏÎÎÎÎÏÏÎÏÏÎ ÏÏÎÏÏÎÏÎÎÎ GMenu."
+
+#: C/window.vala.page:32(p) C/window.py.page:34(p) C/window.c.page:34(p)
+#: C/treeview_simple_liststore.vala.page:26(p) C/toolbar.vala.page:28(p)
+#: C/toolbar.js.page:25(p) C/togglebutton.vala.page:27(p)
+#: C/togglebutton.py.page:26(p) C/textview.py.page:31(p)
+#: C/switch.vala.page:30(p) C/switch.py.page:30(p) C/statusbar.vala.page:27(p)
+#: C/statusbar.py.page:27(p) C/spinner.vala.page:24(p) C/spinner.py.page:24(p)
+#: C/spinbutton.py.page:25(p) C/scrolledwindow.py.page:24(p)
+#: C/scale.py.page:25(p) C/radiobutton.vala.page:27(p)
+#: C/radiobutton.py.page:27(p) C/progressbar.vala.page:34(p)
+#: C/progressbar.py.page:34(p) C/messagedialog.vala.page:25(p)
+#: C/messagedialog.js.page:24(p) C/linkbutton.py.page:26(p)
+#: C/linkbutton.js.page:24(p) C/label.vala.page:25(p) C/label.js.page:24(p)
+#: C/label.c.page:30(p) C/image.vala.page:26(p) C/image.c.page:27(p)
+#: C/GtkApplicationWindow.vala.page:25(p) C/GtkApplicationWindow.py.page:24(p)
+#: C/GtkApplicationWindow.js.page:25(p) C/GtkApplicationWindow.c.page:24(p)
+#: C/grid.vala.page:26(p) C/grid.py.page:26(p) C/grid.js.page:28(p)
+#: C/gmenu.vala.page:35(p) C/gmenu.py.page:26(p) C/gmenu.js.page:24(p)
+#: C/gmenu.c.page:26(p) C/entry.vala.page:24(p) C/entry.py.page:24(p)
+#: C/dialog.vala.page:26(p) C/dialog.js.page:24(p) C/combobox.vala.page:24(p)
+#: C/checkbutton.vala.page:24(p) C/checkbutton.py.page:24(p)
+#: C/checkbutton.c.page:24(p) C/button.js.page:25(p)
+#: C/aboutdialog.vala.page:31(p) C/aboutdialog.py.page:25(p)
+#: C/aboutdialog.js.page:23(p)
+msgid "In this sample we used the following:"
+msgstr "ÎÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎÎ ÏÎ ÏÎÏÎÎÎÏÏ:"
+
+#: C/window.vala.page:36(link) C/window.py.page:38(link)
+#: C/window.js.page:37(link) C/messagedialog.js.page:30(link)
+#: C/linkbutton.js.page:28(link) C/label.vala.page:29(link)
+#: C/label.js.page:28(link) C/GtkApplicationWindow.vala.page:29(link)
+#: C/GtkApplicationWindow.js.page:29(link) C/grid.py.page:30(link)
+#: C/grid.js.page:32(link) C/gmenu.vala.page:39(link)
+#: C/dialog.js.page:28(link) C/button.js.page:29(link)
+#: C/aboutdialog.vala.page:35(link) C/aboutdialog.js.page:30(link)
+#| msgid "A first Gtk application"
+msgid "Gtk.Application"
+msgstr "ÎÏÎÏÎÎÎÎ Gtk"
+
+#: C/window.vala.page:37(p)
 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>ÎÏÏÎÎÎ</gui><gui>ÎÎÎ</"
-"gui><gui>ÎÏÎÎ</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:"
+"The widget <link href=\"http://www.valadoc.org/#!api=gtk+-3.0/Gtk.Window";
+"\">Gtk.Window</link>"
 msgstr ""
-"ÎÎ ÏÏÎÎÎÏÏÎÎÏÎ ÏÎ ÏÎÏÎÎÎÏÏ ÎÎÎ ÎÎ ÎÏÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÎÏÎÎÏÎÏÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ:"
+"ÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ <link "
+"href=\"http://www.valadoc.org/#!api=gtk+-3.0/Gtk.Window\";>ÏÎÏÎÎÏÏÎ Gtk</link>"
 
-msgid "An installed copy of the <link xref=\"getting-ready\">Anjuta IDE</link>"
+#: C/window.vala.page:39(p)
+msgid ""
+"The enum <link href=\"http://references.valadoc.org/#!api=gtk+-3.0/Gtk.";
+"WindowPosition\">Gtk.WindowPosition</link>"
 msgstr ""
-"ÎÎÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÎÎÏÎÎÏÎÏÎ ÏÎÏ <link xref=\\\"getting-ready\\\">Anjuta IDE</"
-"link>"
+"Î ÎÏÎÎÎÎÏÎ <link href=\"http://references.valadoc.org/#!api=gtk+-3.0/Gtk.Wind";
+"owPosition\">WindowPosition Gtk</link>"
 
-msgid "@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+#: C/window.vala.page:41(p)
+msgid ""
+"The method <link href=\"http://www.valadoc.org/#!api=gtk+-3.0/Gtk.Window.";
+"set_default_size\">set_default_size</link>"
 msgstr ""
-"@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+"Î ÎÎÎÎÎÎÏ <link href=\"http://www.valadoc.org/#!api=gtk+-3.0/Gtk.Window.set_d";
+"efault_size\">set_default_size</link>"
 
-msgid "Jonh Wendell"
-msgstr "Jonh Wendell"
+#: C/window.vala.page:43(link)
+msgid "border_width"
+msgstr "border_width"
 
-msgid "jwendell gnome org"
-msgstr "jwendell gnome org"
+#: C/window.vala.page:45(link)
+msgid "window_position"
+msgstr "window_position"
 
-msgid "Image Viewer"
-msgstr "ÎÏÎÎÎÎÎ ÎÎÎÏÎÏÎ"
+#: C/window.py.page:25(p)
+#| msgid "A first Gtk application"
+msgid "A minimal Gtk+ Application."
+msgstr "ÎÎÎ ÏÏÏÏÎ ÎÏÎÏÎÎÎÎ Gtk+."
 
+#: C/window.py.page:28(p)
 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:"
+"Use <link xref=\"GtkApplicationWindow.py\">Application Window</link> if you "
+"need GMenu support."
 msgstr ""
-"ÎÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ ÎÎ ÏÏÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎÏ ÎÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎ GTK Î ÎÏÎÎÎ "
-"ÏÎÏÏÏÎÎÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ. ÎÎ ÎÎÎÎÏÎ ÏÏÏ:"
-
-msgid "Deal with events by connecting signals to signal handlers"
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ <link xref=\"GtkApplicationWindow.py\">ÏÎÏÎÎÏÏÎ "
+"ÎÏÎÏÎÎÎÎÏ</link> ÎÎÎ ÏÏÎÎÎÎÏÏÎÏÏÎ ÏÏÎÏÏÎÏÎÎÎ GMenu."
+
+#: C/window.py.page:39(link) C/window.js.page:38(link)
+#: C/toolbar.js.page:29(link)
+msgid "Gtk.Window"
+msgstr "ÎÎÏÎÎÏÏÎ Gtk"
+
+#: C/window.js.page:11(name) C/messagedialog.js.page:11(name)
+#: C/linkbutton.js.page:11(name) C/label.js.page:11(name)
+#: C/grid.js.page:16(name) C/dialog.js.page:11(name) C/button.js.page:11(name)
+#: C/aboutdialog.js.page:10(name)
+msgid "Taryn Fox"
+msgstr "Taryn Fox"
+
+#: C/window.js.page:12(email) C/messagedialog.js.page:12(email)
+#: C/linkbutton.js.page:12(email) C/label.js.page:12(email)
+#: C/grid.js.page:17(email) C/dialog.js.page:12(email)
+#: C/button.js.page:12(email) C/aboutdialog.js.page:11(email)
+msgid "jewelfox fursona net"
+msgstr "jewelfox fursona net"
+
+#: C/window.js.page:16(desc)
+msgid "A basic window which can contain other widgets"
+msgstr "ÎÎÎ ÎÎÏÎÎÏ ÏÎÏÎÎÏÏÎ ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ"
+
+#: C/window.js.page:24(p) C/window.c.page:24(p)
+#| msgid "A first Gtk application"
+msgid "A minimal GtkApplication"
+msgstr "ÎÎÎ ÏÏÏÏÎ GtkApplication"
+
+#: C/window.js.page:27(p)
+msgid ""
+"Use <link xref=\"GtkApplicationWindow.js\">ApplicationWindow</link> if you "
+"need GMenu support."
 msgstr ""
-"ÎÎ ÎÎÏÎÎÎÏÏÏÎÎÎÏÎ ÎÎÎÎÎÏÏÎ ÏÏÎÎÎÎÎÏÎÏ ÏÎÎÎÏÎ ÎÎ ÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signals "
-"handlers)"
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ <link xref=\"GtkApplicationWindow.js\">ApplicationWindow</link> "
+"ÎÎÎ ÏÏÎÎÎÎÏÏÎÏÏÎ ÏÏÎÏÏÎÏÎÎÎ GMenu."
 
-msgid "Lay out GTK user interfaces using containers"
-msgstr "ÎÏÎÎÎÎÏÎÏ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ GTK ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÏÎÎÎÏÎÎÏ (containers)"
+#: C/window.js.page:33(p)
+msgid "In this example we used the following:"
+msgstr "ÎÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎÎ ÏÎ ÏÎÏÎÎÎÏÏ:"
 
-msgid "Load and display image files"
-msgstr "ÎÏÏÏÏÏÎ ÎÎÎ ÎÎÏÎÎÎÏÎ ÎÎÎÏÎÏÎ"
+#: C/window.c.page:27(p)
+msgid ""
+"Use <link xref=\"GtkApplicationWindow.c\">Application Window</link> if you "
+"need GMenu support."
+msgstr ""
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ <link xref=\"GtkApplicationWindow.c\">ÏÎÏÎÎÏÏÎ ÎÏÎÏÎÎÎÎÏ</link> "
+"ÎÎÎ ÏÏÎÎÎÎÏÏÎÏÏÎ ÏÏÎÏÏÎÏÎÎÎ GMenu."
+
+#: C/window.c.page:38(link) C/label.c.page:34(link) C/image.vala.page:30(link)
+#: C/image.c.page:31(link) C/GtkApplicationWindow.py.page:28(link)
+#: C/GtkApplicationWindow.c.page:28(link) C/checkbutton.py.page:28(link)
+#: C/aboutdialog.py.page:29(link)
+#| msgid "A first Gtk application"
+msgid "GtkApplication"
+msgstr "GtkApplication"
+
+#: C/window.c.page:39(link) C/radiobutton.py.page:31(link)
+#: C/linkbutton.py.page:30(link) C/label.c.page:35(link)
+#: C/image.c.page:32(link)
+msgid "GtkWindow"
+msgstr "GtkWindow"
+
+#: C/weatherGeonames.js.page:10(name) C/weatherAutotools.js.page:10(name)
+#: C/weatherAppMain.js.page:10(name) C/weatherApp.js.page:10(name)
+#: C/helloworldautotools.js.page:10(name) C/helloWorld.js.page:10(name)
+#: C/guitar-tuner.js.page:10(name) C/grid.js.page:11(name)
+#: C/desktop.js.page:10(name) C/beginner.js.page:10(name)
+msgid "Susanna Huhtanen"
+msgstr "Susanna Huhtanen"
+
+#: C/weatherGeonames.js.page:11(email) C/weatherAutotools.js.page:11(email)
+#: C/weatherAppMain.js.page:11(email) C/weatherApp.js.page:11(email)
+#: C/helloworldautotools.js.page:11(email) C/helloWorld.js.page:11(email)
+#: C/guitar-tuner.js.page:11(email) C/grid.js.page:12(email)
+#: C/desktop.js.page:11(email) C/beginner.js.page:11(email)
+msgid "ihmis suski gmail com"
+msgstr "ihmis suski gmail com"
+
+#: C/weatherGeonames.js.page:18(title)
+msgid "Local library geoNames"
+msgstr "ÎÎÏÎÎÎ ÎÎÎÎÎÎÎÎÎÎ geoNames"
+
+#: C/weatherGeonames.js.page:20(p)
+msgid ""
+"In this part of the guide well construct the local library geoNames using "
+"asynchronous calls. Weather information in this example is fetched from "
+"geonames.org and the application is using the <link href=\"http://en.";
+"wikipedia.org/wiki/List_of_airports_by_ICAO_code:_E\">ICAO codes </link> to "
+"place your weather request. To write and run all the code examples yourself, "
+"you need an editor to write code in, Terminal and GNOME 3 or higher "
+"installed into your computer. In this guide we we'll go through the "
+"following parts:"
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÏ ÏÏÏÎÎÎÏÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎÎ ÎÎÎ ÏÎÏÎÎÎ "
+"ÎÎÎÎÎÎÎÎÎÎ geoNames ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÎÏÏÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ. ÎÎ ÏÎÎÏÎÏÎÏÎÎÏ ÏÎÏ "
+"ÎÎÎÏÎÏ ÏÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎÏÎÏÎÎÏÎÎ ÎÏÏ ÏÎÎ geonames.org ÎÎÎ Î ÎÏÎÏÎÎÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÎ ÏÎ <link "
+"href=\"http://en.wikipedia.org/wiki/List_of_airports_by_ICAO_code:_E\";>ÎÏÎÎÎÎÏ "
+"ICAO</link> ÎÎÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÎ ÏÎÎ ÎÎÏÎÏÎ ÏÎÏ ÎÎÎ ÏÎÎ ÎÎÎÏÏ. ÎÎÎ ÎÎ ÎÏÎÏÎÏÎ "
+"ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÎÏÎÎÎÎÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎ, ÏÏÎÎÎÎÎÏÏÎ ÎÎÎÎ "
+"ÎÏÎÎÎÏÎÎÏÏÎ ÎÎÎ ÎÎ ÎÏÎÏÎÏÎ ÏÎÎ ÎÏÎÎÎÎ, ÏÎÏÎÎÏÎÎÏ ÎÎÎ GNOME 3 Î ÎÎÎÎÎÏÏÎÏÎ "
+"ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÏÏÎÎ ÏÏÎÎÎÎÎÏÏÎ ÏÎÏ. ÎÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ ÎÎ ÎÎÎÏÎÏÎÏÎÎ ÏÎ "
+"ÏÎÏÎÎÎÏÏ ÎÎÏÎ:"
+
+#: C/weatherGeonames.js.page:23(link) C/weatherGeonames.js.page:31(title)
+msgid "Local library for getting the weather"
+msgstr "ÎÎÏÎÎÎ ÎÎÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÏÎ ÏÎÏ ÎÎÎÏÎÏ"
+
+#: C/weatherGeonames.js.page:24(link)
+msgid "Creating function geoNames"
+msgstr "ÎÎÎÎÎÏÏÎÎÎ ÏÏÎÎÏÏÎÏÎÏ geoNames"
+
+#: C/weatherGeonames.js.page:25(link)
+msgid "Methods for geoNames"
+msgstr "ÎÎÎÎÎÎÎ ÎÎÎ geoNames"
+
+#: C/weatherGeonames.js.page:26(link) C/weatherGeonames.js.page:101(title)
+msgid "geonames.js"
+msgstr "geonames.js"
+
+#: C/weatherGeonames.js.page:32(p)
+msgid "For this we need a new file that will be our local library."
+msgstr ""
+"ÎÎÎ ÎÏÏÏ ÎÎ ÏÏÎÎÎÏÏÎÏÎÎ ÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÏÎÏ ÎÎ ÎÎÎÎÎ Î ÏÎÏÎÎÎ ÎÎÏ ÎÎÎÎÎÎÎÎÎÎ."
 
-msgid "A first Gtk application"
-msgstr "ÎÎÎ ÏÏÏÏÎ ÎÏÎÏÎÎÎÎ ÏÎ Gtk"
+#: C/weatherGeonames.js.page:38(p)
+msgid ""
+"In the first lines we'll import and initialize the libraries we need to use "
+"in this local library. Soup handles all the requests we have to make with "
+"http."
+msgstr ""
+"ÎÏÎÏ ÏÏÏÏÎÏ ÎÏÎÎÎÎÏ ÎÎ ÎÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÏÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎÏ ÎÏÎÎÏÎÏÎÎÎÎÏ "
+"ÎÎÎÎÎÎÎÎÎÎÏ ÎÎÎ ÏÏÎÏÎ ÏÎ ÎÏÏÎ ÏÎÎ ÏÎÏÎÎÎ ÎÎÎÎÎÎÎÎÎÎ. ÎÎ Soup ÎÏÎÎÎÏÎÎÎÎÏÎÎ "
+"ÏÎÎÏ ÏÎÏ ÎÎÏÎÏÎÎÏ ÏÎÏ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÏÎÎ ÎÎ http."
 
-msgid "Let's take a look at what's happening:"
-msgstr "ÎÏ ÏÎÎÎÏÎÎ ÎÎÎ ÎÎÏÎÎ ÏÏÎ ÏÎ ÎÎÎÎÏÎÎ:"
+#: C/weatherGeonames.js.page:42(title)
+msgid "Creating function GeoNames"
+msgstr "ÎÎÎÎÎÏÏÎÎÎ ÏÏÎÎÏÏÎÏÎÏ geoNames"
 
+#: C/weatherGeonames.js.page:52(p)
 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."
+"Here we create the function GeoNames that will handle getting weather for "
+"us. JavaScript allows us to create functions that have little inside at "
+"first and later expand them. This will be done inside the GeoNames.prototype "
+"curly braces{}"
 msgstr ""
-"Î ÏÏÏÏÎ ÎÏÎÎÎÎ ÎÎÏÎÎÎÎ ÏÎ Gtk namespace (ÎÏÏÏ ÎÎÎÎÎ ÏÎÏ ÏÎÏÎÎÏÎÎ ÏÎÎ "
-"ÎÎÎÎÎÎÎÎÎÎ ÏÎÏ Gtk). ÎÎ ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏÎÏÎÎÏÎÎ ÎÏÏ ÏÎ GObject Introspection "
-"(gi), ÏÎÏ ÏÎÏÎÏÎÎ ÎÎÏÏÏÎÎÎÏ ÎÏÎÎÏÎÏÎÎÏ ÎÎÎ ÏÎÎÎÎÏ ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏ GNOME."
+"ÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ GeoNames ÏÎÏ ÎÎ ÏÎÎÏÎÏÏÎÎ ÏÎ ÎÎÏÎ ÎÎÎÏÎÏ ÎÎÎ "
+"ÎÎÏ. ÎÎ JavaScript ÎÏÎÏÏÎÏÎÎ ÏÎ ÎÎÎÎÎÏÏÎÎÎ ÏÏÎÎÏÏÎÏÎÏÎ ÏÎÏ ÎÏÎÏÎ ÎÎÎÎ ÎÎÏÎ "
+"ÏÏÎÎ ÎÏÏÎ ÎÎÎ ÎÏÎÏÏÎÏÎ ÏÎÏ ÎÏÎÎÏÎÎÎÎÎ. ÎÏÏÏ ÎÎ ÎÎÎÎÎ ÎÎÏÎ ÏÏÎ ÎÎÎÎÏÏÏÎ {} "
+"ÏÎÏ GeoNames.prototype"
 
-msgid "Signals"
-msgstr "ÎÎÎÎÏÎ"
+#: C/weatherGeonames.js.page:56(title)
+msgid "Methods for GeoNames"
+msgstr "ÎÎÎÎÎÎÎ ÎÎÎ GeoNames"
 
+#: C/weatherGeonames.js.page:96(p)
 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:"
+"The first method for GeoNames is getWeather and the second getIcon. In "
+"getWeather we make a http request with soup, handle errors and then parse "
+"the information from the request to form we can use it. In getIcon we simply "
+"compare the results we got from getWeather to the switch we have in order to "
+"get the icon matching current weather. Now that we have our local library "
+"ready, it's time to make use of it."
 msgstr ""
-"ÎÎ ÏÎÎÎÏÎ ÎÎÎÎÎ ÎÎÎ ÎÏÏ ÏÎÏ ÎÎÎÎÎÎÏ ÎÎÎÎÎÎÎ ÎÎÎ ÏÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÏ ÏÎ Gtk. "
-"ÎÏÎÏÎ ÎÎÏÎ ÏÏÎÎÎÎÎÎÎ ÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ, ÎÎÏÎÎÏÎÎ ÎÎÎ ÏÎÎÎ! ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, "
-"ÏÏÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎ ÎÎÏÎÏÎ ÎÎÏÎÎÏÎÎ ÏÎ ÏÎÎÎ <code>clicked</code>. ÎÎÎ ÎÎÎÎÏÎ "
-"ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÎÎÎÎÎ ÎÎÏÎ ÏÏÎÎ ÎÏÏÏ ÏÏÎÎÎÎÎÎÎ, ÏÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎ "
-"ÏÏÎÎÏÏÎÏÎ (ÎÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ-signal handler) ÏÎ ÎÏÏÏ ÏÎ ÏÎÎÎ. ÎÏÎÏÏÎ ÎÎÎ "
-"ÏÎÏÎÎÎÎÎÎÎ:"
-
+"Î ÏÏÏÏÎ ÎÎÎÎÎÎÏ ÎÎÎ ÏÎ GeoNames ÎÎÎÎÎ Î getWeather ÎÎÎ Î ÎÎÏÏÎÏÎ Î getIcon. "
+"ÎÏÎÎ getWeather ÎÎÎÎÏÎÎ ÎÎÎ ÎÎÏÎÏÎ http ÎÎ soup, ÎÏÎÎÎÏÎÎÏÎÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎ "
+"ÎÏÎÎÏÎ ÎÎÎÎÏÏÎ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÎÏÏ ÏÎÎ ÎÎÏÎÏÎ ÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÏÎÏÎÏÎÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ. ÎÏÎ getIcon ÏÏÎÎÏÎÎÎÏÎÎ ÎÏÎÎ ÏÎ ÎÏÎÏÎÎÎÏÎÎÏÎ ÏÎÏ ÏÎÎÏÎÎÏÎÎ "
+"ÎÏÏ getWeather ÏÏÎÎ ÎÎÎÎÏÏÏÎ ÏÎÏ ÎÏÎÏÎÎ ÎÎÎ ÏÎ ÎÎÏÎ ÎÎÎÎÎÎÎÎÎÏ ÏÎÏ "
+"ÏÎÎÏÎÎÎÎÎ ÏÏÎÎ ÏÏÎÏÎÎÏÎ ÎÎÎÏÏ. ÎÏÏÎ ÏÎÏ ÎÏÎÏÎÎ ÏÎÎ ÏÎÏÎÎÎ ÎÎÏ ÎÎÎÎÎÎÎÎÎÎ "
+"ÎÏÎÎÎÎ, ÎÎÎÎÎ ÎÎÎÏÏÏ ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ."
+
+#: C/weatherGeonames.js.page:102(p)
 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."
+"Here is the entire code for our local library. The main program file calls "
+"this asynchronously."
 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): ÎÏÎÎÎÎÏÎ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎÏ"
+#: C/weatherAutotools.js.page:18(title) C/weatherApp.js.page:29(link)
+msgid "Autotools and Icons"
+msgstr "Autotools ÎÎÎ ÎÎÎÎÎÎÎÎÎ"
 
+#: C/weatherAutotools.js.page:20(p)
 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."
+"In this part of the guide well construct the autotools and custom icons "
+"needed for weather application to be a seamless part of your desktop. To "
+"write and run all the code examples yourself, you need an editor to write "
+"code in, Terminal and GNOME 3 or higher installed into your computer. In "
+"this guide we we'll go through the following parts:"
 msgstr ""
-"ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) (ÏÏÏÏ ÏÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎ ÎÏÎÎÎÏÎÏ) ÎÏÎÏÎÏÎ ÎÎ "
-"ÏÎÏÎÎÎÏÎÎÎÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÏÎÏ ÏÏÎÏÎ ÏÏÎ <em>ÏÏÎÎÎÏÎÏÎ (containers)</"
-"em>. ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÎÏÏÎÏÎ ÏÎÎ ÎÎÎÏÎÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏ ÎÎÎÏÎÏÎÏÎÎÏÎ ÎÎÎÏÎ "
-"ÏÏÎÎÎÏÎÎÏ (containers), ÏÏÏÏ ÎÎÏÏÎÎ ÎÎÎ ÏÎÎÎÎÎÏÎ."
-
+"ÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÏ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎÎ ÏÎ ÎÏÏÏÎÎÏÎ ÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎ "
+"ÏÏÎÏÎÏÎÏÏÎÏÎÎ ÏÎ ÎÏÎÎÏÎÏÎÎÎÎ ÎÎÎÎÎÎÎÎÎ ÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÎÎÎÏÎÏ ÎÎÎ ÎÎ ÎÎÎÎÎ "
+"ÎÏÏÎÏÎ ÎÎÏÎÏ ÏÎÏ ÎÏÎÏÎÎÎÎÎÏ ÎÏÎÎÏÎÎÏ ÏÎÏ. ÎÎÎ ÎÎ ÎÏÎÏÎÏÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎ ÏÎÎ "
+"ÏÎ ÏÎÏÎÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ ÎÎ ÎÎÎÎÎ, ÏÏÎÎÎÎÏÏÎÏÏÎ ÎÎÎÎ ÎÏÎÎÎÏÎÎÏÏÎ ÎÎÎ ÎÎ "
+"ÎÏÎÏÎÎÎ ÏÎÏ ÎÏÎÎÎÎ, ÏÎÏÎÎÏÎÎÏ ÎÎÎ GNOME 3 Î ÎÎÏÎÎÎÎÎÏÏÎÏÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÏÏÎÎ "
+"ÏÏÎÎÎÎÎÏÏÎ ÏÎÏ. ÎÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ ÎÎ ÎÎÎÏÎÏÎÏÎÎ ÏÎ ÏÎÏÎÎÎÏÏ ÎÎÏÎ:"
+
+#: C/weatherAutotools.js.page:23(link)
+msgid "Autotools"
+msgstr "Autotools"
+
+#: C/weatherAutotools.js.page:24(link) C/weatherAutotools.js.page:144(title)
+msgid "Custom icons for your application"
+msgstr "ÎÏÎÏÎÏÎÎÎÎ ÎÎÎÎÎÎÎÎÏÎ ÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ"
+
+#: C/weatherAutotools.js.page:31(title)
+msgid "Autotools and necessary files"
+msgstr "Autotools ÎÎÎ ÎÏÎÏÎÎÏÎÏÎ ÎÏÏÎÎÎ"
+
+#: C/weatherAutotools.js.page:32(p)
 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."
+"Having more than one file in your folder makes using autotools a bit tricky. "
+"You need the .desktop file, autogen.sh, Makefile.am, configure.ac and as a "
+"new file: myapp.sh.in file. Hacking the autotools file is a complicated "
+"field. More information can be found in many different sources, <link href="
+"\"http://en.wikipedia.org/wiki/GNU_build_system\";>the wikipedia article</"
+"link> provides a good overwiev on the subject."
 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), "
-"ÏÎÏÎÎÎÏÎÎÎÎÎ ÎÏÎÎÏÎÏÎÎ Î ÎÎÎÎÏÎ. ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎÏÎ ÎÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎÏ "
-"ÎÎÎÏÎÎÎÎÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎÎÎ ÎÎÏÏÎÎ ÏÎ ÎÎÎ ÎÎÏÎ ÏÏÎ ÎÎÎÎ."
-
+"ÎÏÎÎÏÎÏ ÏÎÏÎÏÏÏÏÎÏÎ ÎÏÏ ÎÎÎ ÎÏÏÎÎÎ ÏÏÎÎ ÏÎÎÎÎÏ ÏÎÏ ÎÎÎÎÎ ÏÎ ÏÏÎÏÎ ÏÎÏ "
+"autotools ÎÎÎÎ ÏÎÏÎÏÎÎÎÎ. ÎÏÎÎÎÎÏÏÎÏÏÎ ÏÎ ÎÏÏÎÎÎ .desktop, autogen.sh, "
+"Makefile.am, configure.ac ÎÎÎ ÏÏ ÎÎÎ ÎÏÏÎÎÎ: ÏÎ ÎÏÏÎÎÎ myapp.sh.in. Î "
+"ÎÏÎÎÎÏÎÎÏÎÎ ÏÎÏ ÎÏÏÎÎÎÏ autotools ÎÎÎÎÎ ÎÎÎ ÏÎÏÎÏÎÎÎÎ ÏÎÎÎÎ. ÎÎÏÎÏÏÏÏÎÏÎÏ "
+"ÏÎÎÏÎÏÎÏÎÎÏ ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÏÎ ÏÎ ÏÎÎÎÎÏ ÎÎÎÏÎÏÎÏÎÎÎÏ ÏÎÎÎÏ, <link "
+"href=\"http://en.wikipedia.org/wiki/GNU_build_system\";>ÏÎ ÎÏÎÏÎ ÏÎÏ "
+"ÎÎÎÎ</link> ÏÎÏÎÏÎÎ ÎÎÎ ÎÎÎÎ ÎÏÎÏÎÏÏÎÏÎ ÏÎÏ ÎÎÎÎÏÎÏ."
+
+#: C/weatherAutotools.js.page:35(p) C/weatherAutotools.js.page:41(p)
+msgid "weatherapp.desktop"
+msgstr "weatherapp.desktop"
+
+#: C/weatherAutotools.js.page:36(p) C/weatherAutotools.js.page:56(p)
+msgid "weatherapp.sh.in"
+msgstr "weatherapp.sh.in"
+
+#: C/weatherAutotools.js.page:37(p) C/weatherAutotools.js.page:63(p)
+#: C/helloworldautotools.js.page:23(p) C/helloworldautotools.js.page:34(p)
+msgid "Makefile.am"
+msgstr "Makefile.am"
+
+#: C/weatherAutotools.js.page:38(p) C/weatherAutotools.js.page:130(p)
+#: C/helloworldautotools.js.page:24(p) C/helloworldautotools.js.page:45(p)
+msgid "configure.ac"
+msgstr "configure.ac"
+
+#: C/weatherAutotools.js.page:39(p) C/helloworldautotools.js.page:22(p)
+#: C/helloworldautotools.js.page:27(p)
+msgid "autogen.sh"
+msgstr "autogen.sh"
+
+#: C/weatherAutotools.js.page:54(p)
 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."
+"The thing to notice in this file is that the Exec line will make this ."
+"desktop file work only after running all the other makefiles. Weatherapp.sh "
+"is a small shell script created with the weatherapp.sh.in."
 msgstr ""
-"ÎÏÎÏÏÎÎ ÎÎÎÏ ÏÏÎÎÎÎÏÏÎÏ ÎÏÎÏÎÎÎÏ ÏÎÏÎÎÎÎÎÎÎÏÎÏ ÎÎ ÏÎÎÎÎ <app>Glade</app> "
-"ÎÎÏÏÎÎÏÏÎÎÎÎ ÏÏÎ <app>Anjuta</app> ÏÎ ÎÏÎÎÎ ÎÎÎÎÎ ÏÎ ÏÏÎÎÎÎÏÎ ÎÏÎÏÎÎÎÏ "
-"ÏÎÏÎÎÎÎÎÎÎÏÎÏ ÏÎÎÏ ÎÏÎÎÎÎ. ÎÎÎ ÎÏÏÏ ÏÎ ÎÏÎÏ ÏÎÏÎÎÎÎÎÎÎ, ÏÎÏÏ, ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ "
-"ÏÎÎÏÎ ÏÎ ÎÏÎÎÎÎ."
+"ÎÏÏÏ ÏÎÏ ÏÏÎÏÎÎ ÎÎ ÏÎÎÎÎÏÏÎÏÎ ÏÎ ÎÏÏÏ ÏÎ ÎÏÏÎÎÎ ÎÎÎÎÎ ÏÏÎ Î ÎÏÎÎÎÎ Exec ÎÎ "
+"ÎÎÎÎÎ ÎÏÏÏ ÏÎ ÎÏÏÎÎÎ .desktop ÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÎ ÎÎÏÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏÎ ÏÏÎ "
+"ÎÎÎÏÎ makefiles. ÎÎ Weatherapp.sh ÎÎÎÎÎ ÎÎÎ ÎÎÎÏÏ ÏÎÎÎÏÎÎ ÎÎÎÏÏÎÏÏ ÏÎÏ "
+"ÎÎÎÎÎÏÏÎÎÎÎÎÎ ÎÎ ÏÎ weatherapp.sh.in."
 
+#: C/weatherAutotools.js.page:61(p)
 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"
+"This file is a template to the file Makefile will do to be run from .desktop."
 msgstr ""
-"ÎÏÏÎÎÏÎÏÎÎ: ÎÏÏÏÎÎÏÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ (widgets) ÏÏÎÏÏ ÏÏÎÎÎÏÎÎÏ "
-"(container)"
+"ÎÏÏÏ ÏÎ ÎÏÏÎÎÎ ÎÎÎÎÎ ÎÎÎ ÏÏÏÏÏÏÎ ÏÏÎ ÎÏÏÎÎÎ Makefile ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÎÏÏ "
+".desktop."
 
+#: C/weatherAutotools.js.page:124(p)
 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."
+"This needs a bit more explaining. Compared to the HelloWorld Makefile.am "
+"this has changed quite a bit. Lets go through all the new blocks:"
 msgstr ""
-"ÎÎ ÏÏÎÎÎÏÎÎÏ (containers) (ÎÎÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ-widgets) ÏÎÏ Gtk "
-"ÎÏÎÎÏÎÎÎÎÎÏÎÎ ÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎ ÎÎÎÏÏÏÎÏÎ ÏÎÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ, ÎÎ ÏÎ ÎÏÎÎÎÎÎÏÎ. "
-"ÎÎÎ ÏÎÏÎÎÎÏÎÎÏÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÎÎÎÎÎÏÎÏ ÏÎÏÏ ÎÎÏÎÎÎÏ, x, y-"
-"ÏÏÎÏÎÏÎÎÎÎÎÎÏ ÏÏÎ ÏÎÏÎÎÏÏÎ! ÎÎÎÎ, ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÏÎ ÏÎ ÎÎÎ ÎÎ ÏÎ ÎÎÎÎ. "
-"ÎÏÏÏ ÎÎÎÎÎ ÏÎÎ ÎÎÎÏÎÎÏÎÏÎ ÏÎÏ ÎÎÎÎÎÎÏ ÏÎÏ ÎÎÎÎÎÎÏÏ ÏÎÏ ÏÎÏÎÎÏÏÎÏ ÏÎÎ ÎÏÎÎÎÎ, "
-"ÎÎÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÏÏÎÏ ÏÎÏÎÏÏÏÏÎÏÎÏ ÏÎÏÎÏÏÏÏÎÎÏ ÎÎ ÏÎÏÎÏÎ "
-"ÎÏÏ ÎÏÎÎ ÏÎÏÏ ÎÎÎ ÎÎÎÎÎÏ ÎÎÎÎÎÎÏ."
+"ÎÏÏÏ ÏÏÎÎÎÎÎÏÎÎ ÎÎÎÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎÎÎÏÎ. ÎÏÎÎÏÎÎÏÎÎÎÎ ÎÎ ÏÎ HelloWorld "
+"Makefile.am ÎÏÏÏ ÎÏÎÎ ÎÎÎÎÎÎÎ ÎÏÎÎÏÎ. ÎÏ ÎÎÎÏÎÏÎÏÎÎ ÏÎÎÏ ÏÎÏ ÎÎÎÏ ÎÎÎÎÎÏ:"
 
+#: C/weatherAutotools.js.page:125(p)
 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."
+"bin_scripts are the files that are needed to run your application. In thin "
+"case they are the first two files are the program itself and the third is "
+"the script that launches the application."
 msgstr ""
-"ÎÏÎÏÎÏ ÏÎÎÎÎÏÏÏÎ ÏÏÏ ÏÎ widgets ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÎÎ ÎÎÎ ÎÎÏÎÏÏÎÎ. ÎÏÎÎÏ "
-"ÏÎÏÎÎÎÏÎÎÎÎÎ ÎÎÏÎ ÏÏÎ <code>Gtk.Box</code>, ÏÎ <code>Gtk.Image</code> "
-"ÎÎÏÏÎÎÏÎÎ <em>ÎÏÎÎÏÏÎÎÏ</em> ÏÎÏ <code>Gtk.Box</code>. ÎÏÏÏ ÎÎÏ ÎÎÎÎÎ ÏÎÎ "
-"ÎÏÎÎÏÏÏÎÏÎ ÎÎ ÏÏÎÏÎÏÎÏÎÏÎÎÏÎÎ ÏÎ ÏÎÎ ÏÎ ÎÏÎÎÏÏÎÎÎ ÎÎÏÏ ÎÏÎÏÎÎÎÏ ÏÏÎÎÏÎÎÎÏ "
-"(widget) ÏÏ ÎÎÎ ÎÎÎÎÎ! ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÏÏÎÏÎ ÏÎ <code>Gtk.Box</"
-"code>, ÏÎ ÎÏÎÎÎ ÎÎ ÎÏÏÏÎÎ ÏÎÎÏ ÏÎ ÎÏÎÎÏÏÎÎÎ ÏÎÏ ÏÎÎ ÎÎÎÎ ÏÏÎÎÎÎ."
+"bin_scripts ÎÎÎÎÎ ÏÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÎÏÎÏÎÏÎÎ ÎÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÏÎÎÎÎÏ ÏÎÏ. "
+"ÎÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÎÎÎ ÏÎ ÏÏÏÏÎ ÎÏÎ ÎÏÏÎÎÎ ÏÎÏ ÎÎÎÎÏ ÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏ "
+"ÎÎÎ ÏÎ ÏÏÎÏÎ ÎÎÎÎÎ ÏÎ ÏÎÎÎÏÎÎ ÏÎÏ ÎÎÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ."
 
-msgid "Now insert these two lines, below the two you just added:"
+#: C/weatherAutotools.js.page:126(p)
+msgid "EXTRA_DIST are the files that are to be distributed"
+msgstr "EXTRA_DIST ÎÎÎÎÎ ÏÎ ÎÏÏÎÎÎ ÏÎÏ ÏÏÏÎÎÎÏÎÎ ÎÎ ÎÎÎÎÎÎÎÎÎÏÎ"
+
+#: C/weatherAutotools.js.page:127(p)
+msgid "do_subst block is bits and pieces that need to be where they are"
 msgstr ""
-"ÎÏÏÎ ÏÏÎÏÎÎÏÏÎ ÎÏÏÎÏ ÏÎÏ ÎÏÎ ÎÏÎÎÎÎÏ, ÎÎÏÏ ÎÏÏ ÎÏÏÎÏ ÏÎÏ ÎÏÎÎÏ ÏÏÎÏÎÎÏÎÏÎ:"
+"ÎÎÎÎÎ do_subst ÎÎÎÎÎ ÎÏÎÎÎÎÎ ÎÎÎ ÎÎÎÎÎÏÎÎ ÏÎÏ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎÎ ÏÎÏ "
+"ÎÏÎÏÎÎÎÏÎÎ"
 
+#: C/weatherAutotools.js.page:128(p)
 msgid ""
-"Loading the image: Connecting to the button's <code>clicked</code> signal"
+"after the comment #icons in the application there are all the icons that are "
+"used by the program. For them to be useful you need to install the icons in "
+"correct places and that is done byt the install-icons: bit"
 msgstr ""
-"ÎÏÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÎÏ: ÎÏÎÎÎÏÎ ÏÏÎ ÏÎÎÎ ÏÎÏ ÎÎÏÎÏÎÎÏ <code>clicked</code>"
+"ÎÎÏÎ ÏÎ ÏÏÏÎÎÎ #icons in the application ÏÏÎÏÏÎÏÎ ÏÎÎ ÏÎ ÎÎÎÎÎÎÎÎÎ ÏÎÏ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÏÏ ÏÎ ÏÏÏÎÏÎÎÎÎ. ÎÎÎ ÎÎ ÎÎÎÎÎ ÏÏÎÏÎÎÎ ÎÏÏÎ ÏÏÎÏÎÎ ÎÎ "
+"ÎÎÎÎÏÎÏÏÎÏÎÏÎ ÏÎ ÎÎÎÎÎÎÎÎÎ ÏÎ ÏÏÏÏÎÏ ÎÎÏÎÎÏ ÎÎÎ ÎÏÏÏ ÎÎÎÎÏÎÎ ÎÏÏ ÏÎ install-"
+"icons: bit"
 
-msgid "Loading the image: Writing the signal's callback"
-msgstr "ÎÏÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÎÏ: ÎÏÎÏÎÎÏÎÏ ÏÎÎ ÎÏÎÎÎÎÎÎÏÎ (callback) ÏÎÏ ÏÎÎÎÏÎÏ"
+#: C/weatherAutotools.js.page:137(p)
+msgid "autohen.sh"
+msgstr "autohen.sh"
 
+#: C/weatherAutotools.js.page:145(p)
 msgid ""
-"This is a bit more complicated than anything we've attempted so far, so "
-"let's break it down:"
+"When thinking about custom icons a good rule of thumb is: do you expect to "
+"see that icon used elsewhere or is it private to your app? If the first (e."
+"g. the icons in the desktop file that are shown by the shell) then you need /"
+"usr/share/hicolor, otherwise (e.g. the weather icons of your app) /usr/share/"
+"$application/bla/bla"
 msgstr ""
-"ÎÏÏÏ ÎÎÎÎÎ ÎÎÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎ ÎÏÏ ÏÏÎ ÎÏÎÏÎÎ ÎÎÎÎÎ ÎÎÏÏÎ ÏÏÏÎ, ÎÎÎ ÎÏÏÏ ÎÎ "
-"ÏÎ ÏÏÏÎÏÎÏÎÎ ÏÎ ÎÎÎÎÎÏÎÎ:"
-
+"ÎÎÎ ÏÎÎÏÏÎÏÏÎ ÏÎ ÏÏÎÏÎÏÎÎÏÎÎÎÎ ÎÎÎÎÎÎÎÎÎ ÎÎÎÏ ÎÎÎÏÏ ÏÏÏÏÎÎÏÎÏ ÎÎÎÏÎÎÏ ÎÎÎÎÎ "
+"Î ÎÎÎÏ: ÏÎÏÎÎÎÎÎÏÎ ÎÎ ÎÎÎÏÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÏÎÏ ÎÎÎÎÏ "
+"Î ÎÎÎÎÎ ÎÏÎÎ ÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ; ÎÎÎ ÏÏÎÎÎÎÎÎÎ ÏÎ ÏÏÏÏÎ (Ï.Ï. ÏÎ "
+"ÎÎÎÎÎÎÎÎÎ ÏÏÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÏÎÎÎÎÎÏ ÎÏÎÎÏÎÎÏ ÏÎÏ ÎÎÏÎÎÎÎÎÎÏÎÎ ÎÏÏ ÏÎ "
+"ÎÎÎÏÏÎÏ) ÏÏÏÎ ÏÏÎÎÎÎÏÏÎÏÏÎ /usr/share/hicolor, ÎÎÎÎÏÏ (Ï.Ï. ÏÎ ÎÎÎÎÎÎÎÎÎ "
+"ÎÎÎÏÎÏ ÏÎÏ ÎÏÎÏÎÎÎÎÏ ÏÎÏ) /usr/share/$application/bla/bla"
+
+#: C/weatherAutotools.js.page:146(p)
 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>."
+"Using autotools you have to make some changes to your .desktop and Makefile."
+"am files. In the desktop file you change the Icon's name Icon=weather-icon. "
+"In the Makefile.am file you add these two lines to the end of your "
+"application #the application icon"
 msgstr ""
-"ÎÎ ÎÏÏÎÎÎÎÏ ÎÏÎ ÎÏÎÎÎÎÏ ÏÏÎÏÎÎÏÎÏÎ ÏÎ ÎÎÏÎÏÎÎ <gui>Cancel</gui> ÎÎÎ "
-"<gui>Open</gui> ÏÏÎ ÎÎÎÎÎÎÎ. Î ÎÎÏÏÎÏÎ ÏÎÏÎÎÎÏÏÎÏ (argument) ÏÎÏ ÎÎÎÏÎÎÏ ÏÎÏ "
-"<code>add_button</code> ÎÎÎÎÎ Î (ÎÎÎÏÎÎÎ) ÏÎÎÎ ÏÎÏ ÎÏÎÏÏÏÎÏÎÎ ÏÏÎÎ ÏÎÏÎÎÏÎÎ "
-"ÏÎ ÎÎÏÎÏÎ: 0 ÎÎÎ ÏÎ <gui>ÎÎÏÏÏÏÎ</gui> ÎÎÎ 1 ÎÎÎ ÏÎ <gui>ÎÎÎÎÎÎÎ</gui>."
+"ÎÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ autotools ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÏÎ ÎÎÏÎÎÎÏ ÎÎÎÎÎÎÏ ÏÏÎ ÎÏÏÎÎÎ ÏÎÏ "
+".desktop and Makefile.am. ÎÏÎ ÎÏÏÎÎÎ ÎÏÎÏÎÎÎÎÎÏ ÎÏÎÎÏÎÎÏ ÎÎÎÎÎÏÎ ÏÎ ÏÎÎÎÎ "
+"ÏÎÏ ÎÎÎÎÎÎÎÎÎÏ Icon=weather-icon. ÎÏÎ ÎÏÏÎÎÎ Makefile.am ÏÏÎÏÎÎÏÏÎ ÎÏÏÎÏ ÏÎÏ "
+"ÎÏÎ ÎÏÎÎÎÎÏ ÏÏÎ ÏÎÎÎÏ ÏÎÏ ÎÏÎÏÎÎÎÎ ÏÎÏ #the application icon"
 
+#: C/weatherAutotools.js.page:147(p)
+msgid "appicondir=$(datadir)/icons/hicolor/scalable/apps"
+msgstr "appicondir=$(datadir)/icons/hicolor/scalable/apps"
+
+#: C/weatherAutotools.js.page:148(p)
+msgid "appicon_DATA=weather-icon.svg"
+msgstr "appicon_DATA=weather-icon.svg"
+
+#: C/weatherAppMain.js.page:18(title) C/weatherApp.js.page:27(link)
+msgid "The main program file"
+msgstr "ÎÎ ÎÏÏÎÎ ÎÏÏÎÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏ"
+
+#: C/weatherAppMain.js.page:20(p)
 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."
+"In this part of the guide well construct the main program file of the "
+"weather application. To write and run all the code examples yourself, you "
+"need an editor to write code in, Terminal and GNOME 3 or higher installed "
+"into your computer. In this part we we'll go through the following parts:"
 msgstr ""
-"ÎÎÎÎÎÏÏÏÎ ÏÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ <em>ÏÏÎÎÎÎÎÏÎÏÎÎÎÎ</em> ÎÎÏÎÎÏÎ ÎÎÏÎÏÎÏÎ "
-"ÏÎÏ ÏÏÎÏÏÎÏÎ ÏÏÎ Gtk, ÎÎÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÂÎÎÏÏÏÏÎÂ Î ÂÎÎÎÎÎÎÎÂ. ÎÎ "
-"ÏÎÎÎÎÎÎÏÎÎÎ ÏÏÎ ÏÏÎÏÎ ÏÏÎ ÏÏÎÎÎÎÎÏÎÏÎÎÎÏÎ ÎÎÎÎÎÏÏÎ ÎÎÎÎÎ ÏÏÎ ÎÎ ÎÏÎÎÎÏÎÏ ÏÏÎ "
-"ÎÎÏÎÏÎÏÎ ÎÎ ÎÏÎÏÎ ÎÎÎ ÎÎÏÎÏÏÎÏÏÎÎ ÏÏÎ ÎÎÏÏÏÎ ÏÎÏ ÏÏÎÏÏÎ."
-
+"ÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÏ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎÎ ÏÎ ÎÏÏÎÎ ÎÏÏÎÎÎ ÏÎÏ "
+"ÏÏÎÎÏÎÎÎÎÏÎÏ ÏÎÏ ÎÏÎÏÎÎÎÎÏ ÎÎÎÏÎÏ. ÎÎÎ ÎÎ ÎÏÎÏÎÏÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎ ÏÎÎ ÏÎ "
+"ÏÎÏÎÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ ÎÎ ÎÎÎÎÎ, ÏÏÎÎÎÎÏÏÎÏÏÎ ÎÎÎÎ ÎÏÎÎÎÏÎÎÏÏÎ ÎÎÎ ÏÎ ÎÏÎÏÎÎÎ "
+"ÏÎÏ ÎÏÎÎÎÎ, ÏÎÏÎÎÏÎÎÏ ÎÎÎ GNOME 3 Î ÎÎÏÎÎÎÎÎÏÏÎÏÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÏÏÎÎ "
+"ÏÏÎÎÎÎÎÏÏÎ ÏÎÏ. ÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎ ÎÎ ÎÎÎÏÎÏÎÏÎÎ ÏÎ ÏÎÏÎÎÎÏÏ ÎÎÏÎ:"
+
+#: C/weatherAppMain.js.page:22(link) C/weatherAppMain.js.page:32(title)
+#: C/helloWorld.js.page:22(link) C/helloWorld.js.page:34(title)
+#: C/guitar-tuner.js.page:24(link) C/guitar-tuner.js.page:46(title)
+#| msgid "Run the application"
+msgid "Script for running the application"
+msgstr "ÎÎÎÎÏÎÎ ÎÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÏÎÎÎÎÏ"
+
+#: C/weatherAppMain.js.page:23(link) C/weatherAppMain.js.page:40(title)
+#: C/helloWorld.js.page:23(link) C/helloWorld.js.page:41(title)
+#: C/guitar-tuner.js.page:25(link) C/guitar-tuner.js.page:53(title)
+msgid "Libraries to import"
+msgstr "ÎÎÎÎÎÎÎÎÎÎÏ ÎÎÎ ÎÎÏÎÎÏÎÎ"
+
+#: C/weatherAppMain.js.page:24(link) C/weatherAppMain.js.page:48(title)
+#: C/helloWorld.js.page:24(link) C/helloWorld.js.page:48(title)
+#: C/guitar-tuner.js.page:26(link) C/guitar-tuner.js.page:62(title)
+msgid "Creating the main window for the application"
+msgstr "ÎÎÎÎÎÏÏÎÎÎ ÏÎÏ ÎÏÏÎÎÏ ÏÎÏÎÎÏÏÎÏ ÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ"
+
+#: C/weatherAppMain.js.page:25(link) C/weatherAppMain.js.page:63(title)
+msgid "Adding a grid and all the necessary widgets to it"
+msgstr "ÎÏÎÏÎÎÎÎ ÏÎÎÎÎÎÏÎÏ ÎÎÎ ÏÎÏÎ ÏÏÎ ÎÏÎÏÎÎÏÎÏÏÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ ÏÎ ÎÏÏÏ"
+
+#: C/weatherAppMain.js.page:26(link) C/weatherAppMain.js.page:94(title)
+msgid "Requesting the weather information asynchronously"
+msgstr "ÎÎÏÎÏÎ ÏÏÎ ÏÎÎÏÎÏÎÏÎÏÎ ÎÎÎÏÎÏ ÎÏÏÎÏÏÎÎÎ"
+
+#: C/weatherAppMain.js.page:27(link)
+msgid "Connecting signals to button and entry.\"&gt;"
+msgstr "ÎÏÎÎÎÏÎ ÏÎÎÎÏÏÎ ÏÎ ÎÎÏÎÏÎ ÎÎÎ ÎÎÏÎÏÏÏÎÏÎ.\"&gt;"
+
+#: C/weatherAppMain.js.page:28(link)
+msgid "weatherapp.js"
+msgstr "weatherapp.js"
+
+#: C/weatherAppMain.js.page:35(p)
 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)."
+"This line tells how to run the script. It needs to be the first line of the "
+"code and it needs to be executable. To get the execution rights go to "
+"Terminal and run in right folder: chmod +x scriptname. Or you can use the "
+"graphical filemanager. Just go to the right folder where your code is, right "
+"click you code file, choose properties, click the permissions tab and check "
+"the box for allow executing file as a program"
 msgstr ""
-"To <code>set_default_response</code> ÎÎÎÎÏÎÎÎÎ ÏÎÎÎ ÎÎÏÎÏÎ ÎÎ ÎÎÎÏÎÎÏÎÎÎÎÎÎ "
-"ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÎÏÎÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎ ÎÎÏÎÏ ÎÎÎÎ Î ÏÎÏÎÏÎÎ <key>Enter</key>. "
-"ÎÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÏ, ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÎÎÏÎÏÎ <gui>ÎÎÎÎÎÎÎ</gui> ÏÎÎ "
-"ÏÏÎÎÏÎÎÎÎÎÎÎÎ (ÏÎ ÎÏÎÎÎ ÎÏÎÎ ÏÎÎÎ 1)."
-
+"ÎÏÏÎ Î ÎÏÎÎÎÎ ÎÎÎÎ ÏÏÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÎ ÏÎÎÎÏÎÎ. ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ Î ÏÏÏÏÎ "
+"ÎÏÎÎÎÎ ÏÎÏ ÎÏÎÎÎÎ ÎÎÎ ÎÎ ÎÎÎÎÎ ÎÎÏÎÎÎÏÎÎÎ. ÎÎÎ ÎÎÏÎ ÏÏÎ ÎÎÎÎÎÏÎÎÏÏÎ "
+"ÎÎÏÎÎÎÏÎÏ ÏÎÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÏÎÎÏÎÎÏ ÎÎÎ ÎÎÏÎÎÎÏÏÎ ÏÏÎÎ ÏÏÏÏÏ ÏÎÎÎÎÎ: chmod +x "
+"ÏÎÎÎÎ ÏÎÎÎÏÎÎÏ. Î ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎÎ ÎÎÎÏÎÎÏÎÏÏÎ ÎÏÏÎÎÎÏ "
+"ÎÏÎÏÎÎÏÎ. ÎÏÎÎ ÏÎÎÎÎÎÎÏÎ ÏÏÎÎ ÏÏÏÏÏ ÏÎÎÎÎÎ ÏÏÎÏ ÎÎÎÎÎ Î ÎÏÎÎÎÎÏ ÏÎÏ ÎÎÎÎ "
+"ÎÎÎÎ ÏÏÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÎÎÎ ÏÎÏ, ÎÏÎÎÎÎÏÎ ÎÎÎÏÏÎÏÎÏ, ÎÎÎÎ ÏÏÎÎ ÎÎÏÏÎÎÎ "
+"ÎÎÎÎÎÏÎÎÏÏÎ ÎÎÎ ÏÎÎÎÎÏÏÏÎ ÏÎ ÏÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÏÎÏÏÎÏÎÎ Î ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÏÎÎÎÏ "
+"ÏÏ ÏÏÏÎÏÎÎÎÎ"
+
+#: C/weatherAppMain.js.page:44(p)
 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."
+"In order to have a working program we need to import a GObject Introspection "
+"-library to our use. For working UI, we need Gtk. Gtk is imported in the "
+"beginning so we have it in our use everywhere. We also import our own local "
+"JavaScript library geonames to our use here."
 msgstr ""
-"ÎÎ ÎÏÏÎÎÎÎÏ ÏÏÎÎÏ ÎÏÎÎÎÎÏ ÏÎÏÎÎÏÎÎÎÏÎ ÏÎ ÎÎÎÎÎÎÎ <gui>ÎÎÎÎÎÎÎ</gui> ÎÎ "
-"ÎÎÏÎÎÎÎÎÎ ÎÏÎÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÏÎÎÏÎ ÎÏÏ ÏÎ <code>Gtk.Image</"
-"code>. ÎÎÎÎÎÏÏÎÎÏÎÎ ÏÏÏÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ ÏÎÎÏÏÎÏÂ ÏÏÎÏÎÎÏÎÏÎÎ ÏÏÎ ÏÎÎÏÏÎ "
-"ÏÎÏÎ ÏÏÎ ÎÎÎÏÎ ÎÏÏÎÎÎ ÏÎÏ ÏÏÎÏÏÎÏÎÎÎÎÏÎÎ ÎÏÏ ÏÎ <code>Gdk.Pixbuf</code> (ÏÎ "
-"ÎÏÎÎÎ ÏÎÏÎÎÏÎÎ ÏÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎÎ ÎÎÎÏÎÏÎ ÏÏÏÏ PNG ÎÎÎ JPEG). ÎÎÎÎÏ, "
-"ÎÎÎÎÏÎÎÎÏÎÎ ÏÎ ÏÎÎÏÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ <gui>ÎÎÎÎÎÎÎ</gui>."
+"ÎÎÎ ÎÎ ÎÏÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÎÏÎÎÏÎÎÏ ÏÏÏÎÏÎÎÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÎÎÎ "
+"ÎÎÎÎÎÎÎÎÎÎ GObject ÎÏÏÎÎÎÎÏÏÎÏ ÎÎÎ ÏÏÎÏÎ. ÎÎÎ ÏÏÎÏÎ UI, ÏÏÎÎÎÎÏÎÎÏÏÎ Gtk. ÎÎ "
+"Gtk ÎÎÏÎÎÎÏÎÎ ÏÏÎÎ ÎÏÏÎ, ÎÏÏÎ ÏÎ ÎÏÎÏÎÎ ÎÎÎ ÏÏÎÏÎ ÏÎÎÏÎÏ. ÎÎÏÎÎÎÏÎÎ ÎÏÎÏÎÏ "
+"ÏÎ ÎÎÎÎÎ ÎÎÏ ÏÎÏÎÎÎ ÎÎÎÎÎÎÎÎÎÎ JavaScript geonames ÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ "
+"ÎÎÏ."
 
+#: C/weatherAppMain.js.page:90(p)
 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."
+"In this section we create the grid we are going to use for positioning the "
+"widgets. All the buttons, labels and entrys are initialized and placed on "
+"the grid. As seen from the placing of the different widgets, they don't need "
+"to be related only to one widget. At this point some of the labels don't "
+"have any content. The content for those widgets is applied later. If you run "
+"the application at this stage, you have the UI ready, but the widgets are "
+"not connected to anything. For this we need to first build the weather "
+"searching local library, and then get the information we need "
+"asynchronously. When we have our local library ready we can connect it to "
+"the necessary widgets."
 msgstr ""
-"ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎ ÏÎ <gui>ÎÎÎÎÎÎÎ</gui>, Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ "
-"ÎÏÎÎÎÎ ÏÎÎ ÎÎÎÏÏÎÏÎ <code>file</code> ÏÎÏ <code>Gtk.Image</code> ÏÏÎ ÏÎÎÎÎ "
-"ÏÎÏ ÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎÎ Î ÏÏÎÏÏÎÏ. ÎÎ <code>Gtk.Image</code> ÎÎ "
-"ÏÎÏÏÏÏÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎÎ ÎÏÎÎÎÎÎÎÎÎ ÎÎÎÏÎÎ."
-
+"ÎÎ ÎÎÏÏÎÏÎ ÎÏÏÎÎ ÏÎÎ ÎÎÏÏÎÏÎ ÎÎÎÎÎÏÏÎÎÏÎÎ ÏÎ ÏÎÎÎÎÎ ÏÎÏ ÏÏÏÎÎÎÏÎÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÏÎÏÎÎÎÏÎÏÎ ÏÏÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ. ÎÎÎ ÏÎ ÎÎÏÎÏÎÎ, "
+"ÎÏÎÎÎÏÎÏ ÎÎÎ ÎÎÏÎÏÏÏÎÏÎÎÏ ÎÏÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÏÏÎ ÏÎÎÎÎÎ. ÎÏÏÏ "
+"ÏÎÎÎÎÏÎÎ ÎÏÏ ÏÎÎ ÏÎÏÎÎÎÏÎÏÎ ÏÏÎ ÎÎÎÏÎÏÎÏÎÎÏÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ, ÎÎÎ "
+"ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÎÏÎÎ ÎÏÎÎ ÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ. ÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎÎ "
+"ÎÎÏÎÎÎÏ ÎÏÏ ÏÎÏ ÎÏÎÎÎÏÎÏ ÎÎÎ ÎÏÎÏÎ ÏÎÏÎÎÏÏÎÎÎÎ. ÎÎ ÏÎÏÎÎÏÏÎÎÎÎ ÎÎÎ ÎÏÏÎ ÏÎ "
+"ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÏÎÏÎÏÎÎÏÎÎ ÎÏÎÏÏÎÏÎ. ÎÎÎ ÏÏÎÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎ ÎÏÏÏ ÏÎ "
+"ÏÏÎÎÎÎ, ÎÎ ÎÏÎÏÎ ÎÏÎÎÎÎ ÏÎ UI, ÎÎÎÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÎ "
+"ÏÎÏÎÏÎ. ÎÎÎ ÎÏÏÏ ÏÏÎÎÎÎÏÎÎÏÏÎ ÏÏÏÏÎ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎÎ ÏÎÎ ÏÎÏÎÎÎ ÎÎÎÎÎÎÎÎÎÎ "
+"ÎÎÎÎÎÏÎÏÎÏ ÎÎÎÏÎÏ ÎÎÎ ÎÏÎÎÏÎ ÎÎ ÏÎÏÎÏÎÎ ÏÎÎ ÏÎÎÏÎÏÎÏÎÎ ÏÎÏ ÏÏÎÎÎÎÏÎÎÏÏÎ "
+"ÎÏÏÎÏÏÎÎÎ. ÎÏÎÎ ÎÏÎÏÎÎ ÏÎÎ ÏÎÏÎÎÎ ÎÎÏ ÎÎÎÎÎÎÎÎÎÎ ÎÏÎÎÎÎ, ÎÏÎÏÎÏÎÎ ÎÎ ÏÎ "
+"ÏÏÎÎÎÏÎÏÎÎ ÎÎ ÏÎ ÎÏÎÏÎÎÏÎÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ."
+
+#: C/weatherAppMain.js.page:120(p)
 msgid ""
-"In the final line of this method, we destroy the <gui>Open</gui> dialog "
-"because we don't need it any more."
+"This function is dedicated for calling for the weather information and "
+"updating labels and icons accordingly. In the beginning of the function we "
+"get the user input for the search. So here for the first time we use our own "
+"library and assign it to variable GeoNames. While assigning WeatherService "
+"we give it the station. The firs thing we do with GeoNames is to request "
+"weather. Everything after GeoNames.getWeather(function(error, weather) "
+"happens only if we either get an error message or weather information. If "
+"either doesn't come, the rest of the program works as normal, so main_Quit "
+"works."
 msgstr ""
-"ÎÏÎÎ ÏÎÎÎÏÏÎÎÎ ÎÏÎÎÎÎ ÎÏÏÎÏ ÏÎÏ ÎÎÎÏÎÎÏ, ÎÎÏÎÏÏÏÎÏÎÏÎÎ ÏÎÎ ÎÎÎÎÎÎÎ "
-"<gui>Open</gui> ÎÎÎÏÎ ÎÎÎ ÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎ ÏÎÎ."
-
-msgid "Next steps"
-msgstr "ÎÏÏÎÎÎÎ ÎÎÎÎÏÎ"
-
-msgid "Here are some ideas for how you can extend this simple demonstration:"
+"ÎÏÏÎ Î ÎÎÎÏÎÏÏÎÎÎ ÎÏÎÎÏÏÎÎÏÎÎ ÏÏÎÎ ÎÎÎÏÎ ÎÎÎ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÎÎÎÏÎÏ ÎÎÎ "
+"ÎÎÎÎÎÏÏÏÎ ÎÏÎÎÎÏÏÎ ÎÎÎ ÎÎÎÎÎÎÎÎÏÎ ÎÎÎÎÎÎÎ. ÎÏÎÎ ÎÏÏÎ ÏÎÏ ÎÎÎÏÎÏÏÎÎÎÏ "
+"ÏÎÎÏÎÎÏÎÎ ÏÎÎ ÎÎÏÎÎÎ ÏÏÎÏÏÎ ÎÎÎ ÎÎÎÎÎÏÎÏÎ. ÎÏÏÎ ÎÎÏ ÎÎÎ ÏÎÎ ÏÏÏÏÎ ÏÎÏÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÎÎÎÎ ÎÎÏ ÎÎÎÎÎÎÎÎÎÎ ÎÎÎ ÏÎÏ ÎÏÎÎÎÎÎÏÎÎ ÏÎ ÎÎÏÎÎÎÎÏÎ "
+"GeoNames. ÎÎÏ ÎÎÏÏÏÎÏÎÎ ÏÎÎ WeatherService ÏÎÏ ÎÎÎÎÏÎÎ ÏÎÎ ÏÏÎÎÎÏ. ÎÎ ÏÏÏÏÎ "
+"ÏÏÎÎÎÎ ÏÎÏ ÎÎÎÎÏÎÎ ÎÎ ÏÎ GeoNames ÎÎÎÎÎ Î ÎÎÏÎÏÎ ÎÎÎÏÎÏ. ÎÏÎÎÎÏÎÏÎ ÎÎÏÎ ÏÎ "
+"GeoNamesgetWeather.getWeather (ÏÏÎÎÏÏÎÏÎ (ÏÏÎÎÎÎ, ÎÎÎÏÏÏ) ÏÏÎÎÎÎÎÎÎ ÎÏÎÎ ÎÎÎ "
+"ÎÎÏÎ ÏÎÏÎÏÎÎ ÎÎÎ ÎÎÎÏÎÎ ÏÏÎÎÎÎÏÎÏ Î ÏÎÎÏÎÏÎÏÎÎÏ ÎÎÎÏÎÏ. ÎÎÎ ÎÎÎ ÎÏÎÎÎ "
+"ÎÎÎÎÎÎ, ÏÎ ÏÏÏÎÎÎÏÎ ÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏ ÎÎÏÎÎÏÎÎ ÏÏÏÎ ÎÎÎÎÎÎÎÎ, ÏÏÎ ÏÎ "
+"main_Quit ÎÎÏÎÎÏÎÎ."
+
+#: C/weatherAppMain.js.page:124(title)
+msgid "Connecting signals to button and entry."
+msgstr "ÎÏÎÎÎÏÎ ÏÎÎÎÏÏÎ ÏÎ ÎÎÏÎÏÎ ÎÎÎ ÎÎÏÎÏÏÏÎÏÎ."
+
+#: C/weatherAppMain.js.page:137(p)
+msgid ""
+"And finally we have the connections that make the whole application run as "
+"it should. We connect both the entry and the button to do the same thing, "
+"getting the weather. So it doesn't matter weather you press enter of click "
+"the search button."
 msgstr ""
-"ÎÎÏ ÎÎÎÎÎ ÎÎÏÎÎÎÏ ÎÎÎÎÏ ÎÎÎ ÏÎ ÏÏÏ ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÏÎÎÎÎÏÎ ÎÏÏÎ ÏÎÎ ÎÏÎÎ "
-"ÎÏÎÎÎÎÎÎ:"
-
+"ÎÎÎ ÏÎÎÎÎÎ ÎÏÎÏÎÎ ÏÎÏ ÏÏÎÎÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎ ÏÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÎÎ ÏÏÎÏÎÎ ÏÏÏÏ "
+"ÎÎ ÎÏÏÎÏÎ. ÎÏÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎ ÎÎÏÎÏÏÏÎÏÎ ÎÎÎ ÏÎ ÎÎÏÎÏÎ ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎ ÎÎÎÎ "
+"ÏÏÎÎÎÎ, ÏÎÎÏÎÎÎÏÎÏ ÏÎÎ ÎÎÎÏÏ. ÎÏÏÎ ÎÎÎ ÏÎÎÏÎÎÎÎ, ÎÎÎ ÏÎÏÎÏÎÏÎ ÎÎÎ ÏÎÏÎÏÎÏÎ "
+"ÎÎÏÎÎÏÎÎ Î ÎÎÎÎ ÏÏÎ ÎÎÏÎÏÎ ÎÎÎÎÎÏÎÏÎÏ."
+
+#: C/weatherAppMain.js.page:141(title)
+msgid "Weatherapp.js"
+msgstr "Weatherapp.js"
+
+#: C/weatherAppMain.js.page:142(p)
+msgid "Weatherapp.js file looks like this:"
+msgstr "ÎÎ ÎÏÏÎÎÎ Weatherapp.js ÎÎÎÎÎÎÎ ÎÎ ÎÏÏÏ:"
+
+#: C/weatherAppMain.js.page:228(p)
+msgid "Running until you have all the autotools files ready. :"
+msgstr "ÎÎÏÎÎÎÏÎ ÎÎÏÏÎ ÎÎ ÎÏÎÏÎ ÏÎÎ ÏÎ ÎÏÏÎÎÎ autotools ÎÏÎÎÎÎ. :"
+
+#: C/weatherAppMain.js.page:230(output)
+#: C/helloworldautotools.js.page:33(output)
+#: C/helloworldautotools.js.page:55(output)
+#: C/helloworldautotools.js.page:56(output)
+#: C/helloworldautotools.js.page:57(output) C/helloWorld.js.page:110(output)
+#: C/helloWorld.js.page:111(output) C/guitar-tuner.js.page:229(output)
+msgid "$"
+msgstr "$"
+
+#: C/weatherAppMain.js.page:230(input)
+msgid "GJS_PATH=`pwd` gjs weatherapp.js"
+msgstr "GJS_PATH=`pwd` gjs weatherapp.js"
+
+#: C/weatherAppMain.js.page:231(p)
 msgid ""
-"Have the user select a directory rather than a file, and provide controls to "
-"cycle through all of the images in a directory."
+"Use this command on terminal while developing your modules. When calling "
+"your program in this manner it knows where to find your custom JSlibraries, "
+"in this case geonames.js."
 msgstr ""
-"ÎÎÎÏÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÏÎÎÎÎÎÎ ÎÎÎ ÏÎÎÎÎÎ ÎÎÏÎ ÎÎÎ ÎÏÏÎÎÎ, ÎÎÎ ÏÎÏÎÏÎÏÎ ÏÎÏ ÏÎ "
-"ÎÏÎÎÏÏÏÎÏÎ ÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎ ÏÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ ÏÎ ÎÎÎ ÏÎÎÎÎÎ."
-
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÎÏÏÎÎ ÏÎÎ ÎÎÏÎÎÎ ÏÏÎ ÏÎÏÎÎÏÎÎÏ ÎÎÏ ÎÎÎÏÏÏÏÏÎÏÎ ÏÎ ÎÏÎÏÏÎÎÏÎ "
+"ÏÎÏ. ÎÏÎÎ ÎÎÎÎÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ ÏÎÎ ÏÏÏÏÎ, ÎÎÏÎÎ ÏÎÏ ÎÎ ÎÏÎÎ ÏÎÏ "
+"ÏÏÎÏÎÏÎÎÏÎÎÎÎÏ JSlibraries, ÏÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ ÏÎ geonames.js."
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/weatherApp.js.page:34(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+msgid "@@image: 'media/weatherAppJs.png'; md5=1fe859ac4854273d72ea8fc9203639b2"
+msgstr "@@image: 'media/weatherAppJs.png'Â md5=1fe859ac4854273d72ea8fc9203639b2"
+
+#: C/weatherApp.js.page:15(desc)
 msgid ""
-"Apply random filters and effects to the image when it is loaded and allow "
-"the user to save the modified image."
+"How to plan an application that uses asynchronous calls. Asynchronous calls "
+"will be presented through a weather application."
 msgstr ""
-"ÎÏÎÏÎÏÏÏÎ ÏÏÏÎÎÎ ÏÎÎÏÏÎ ÎÎÎ ÎÏÎ ÏÏÎÎ ÎÎÎÏÎÎ ÏÏÎÎ ÎÏÏÎ ÏÎÏÏÏÎÎÎ ÎÎÎ ÎÏÏÏÎ ÏÎÎ "
-"ÎÏÎÎÏÏÏÎÏÎ ÏÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÏÎÎÎÎÎÏÏÎÎ ÏÎÎ ÎÏÎÎÎÏÎÎÏÎÎÎÎ ÎÎÎÏÎÎ."
+"ÎÏÏ ÎÎ ÏÏÎÎÎÎÏÏÎÎ ÎÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÏÏÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ. ÎÎ "
+"ÎÏÏÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ ÎÎ ÎÎÎÏÎÏÎÏÏÏÎÏÎÎ ÎÎÏÎ ÎÏÏ ÎÎÎ ÎÏÎÏÎÎÎÎ ÎÎÎÏÎÏ."
+
+#: C/weatherApp.js.page:20(title)
+#| msgid "Run the application"
+msgid "4 Weather Application"
+msgstr "4 ÎÏÎÏÎÎÎÎ ÎÎÎÏÎÏ"
 
+#: C/weatherApp.js.page:22(p)
 msgid ""
-"<link href=\"http://www.gegl.org/api.html\";>GEGL</link> provides powerful "
-"image manipulation capabilities."
+"In this guide well construct a weather application using asynchronous calls. "
+"Weather information in this example is fetched from geonames.org and the "
+"application is using the <link href=\"http://en.wikipedia.org/wiki/";
+"List_of_airports_by_ICAO_code:_E\">ICAO codes </link> to place your weather "
+"request. To write and run all the code examples yourself, you need an editor "
+"to write code in, Terminal and GNOME 3 or higher installed into your "
+"computer. In this guide we we'll go through the following parts:"
 msgstr ""
-"ÎÎ <link href=\"http://www.gegl.org/api.html\";>GEGL</link> ÏÎÏÎÏÎÎ ÎÏÏÏÏÎÏ "
-"ÎÏÎÎÏÏÏÎÏÎÏ ÎÏÎÎÎÏÎÎÏÎÎÏ ÎÎÎÏÎÎÏ."
+"ÎÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ ÏÏÏÎÎÎÏÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÎÎ ÎÎÎÏÎÏ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÎÏÏÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ. ÎÎ ÏÎÎÏÎÏÎÏÎÎÏ ÏÎÏ ÎÎÎÏÎÏ ÏÎ ÎÏÏÏ ÏÎ "
+"ÏÎÏÎÎÎÎÎÎÎ ÏÎÏÎÏÎÎÏÎÎ ÎÏÏ ÏÎÎ geonames.org ÎÎÎ Î ÎÏÎÏÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎ ÏÎ "
+"<link "
+"href=\"http://en.wikipedia.org/wiki/List_of_airports_by_ICAO_code:_E\";>ÎÏÎÎÎÎÏ "
+"ICAO</link> ÎÎÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÎ ÏÎÎ ÎÎÏÎÏÎ ÏÎÏ ÎÎÎ ÏÎÎ ÎÎÎÏÏ. ÎÎÎ ÎÎ ÎÏÎÏÎÏÎ "
+"ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÎÏÎÎÎÎÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎ, ÏÏÎÎÎÎÎÏÏÎ ÎÎÎÎ "
+"ÎÏÎÎÎÏÎÎÏÏÎ ÎÎÎ ÎÎ ÎÏÎÏÎÏÎ ÏÎÎ ÎÏÎÎÎÎ, ÏÎÏÎÎÏÎÎÏ ÎÎÎ GNOME 3 Î ÎÎÏÎÎÎÎÎÏÏÎÏÎ "
+"ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÏÏÎÎ ÏÏÎÎÎÎÎÏÏÎ ÏÎÏ. ÎÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ ÎÎ ÎÎÎÏÎÏÎÏÎÎ ÏÎ "
+"ÏÎÏÎÎÎÏÏ ÎÎÏÎ:"
+
+#: C/weatherApp.js.page:25(link) C/weatherApp.js.page:37(title)
+#| msgid "Create the user interface"
+msgid "Planning the graphical user interface"
+msgstr "ÎÏÎÎÎÎÏÎÏÏ ÏÎÏ ÎÏÎÏÎÎÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ"
+
+#: C/weatherApp.js.page:26(link) C/weatherApp.js.page:41(title)
+msgid "Asynchronous calls"
+msgstr "ÎÏÏÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ"
+
+#: C/weatherApp.js.page:28(link)
+msgid "Local library GeoNames"
+msgstr "ÎÎÏÎÎÎ ÎÎÎÎÎÎÎÎÎÎ GeoNames"
+
+#: C/weatherApp.js.page:33(p) C/guitar-tuner.js.page:34(p)
+msgid "After reading this tutorial, you should see this in your screen:"
+msgstr ""
+"ÎÎÏÎ ÏÎÎ ÎÎÎÎÎÏÏÎ ÎÏÏÎÏ ÏÎÏ ÎÎÎÎÎÎÏÎÏ, ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÏÏÏ ÏÏÎÎ ÎÎÏÎÎ "
+"ÏÎÏ:"
 
+#: C/weatherApp.js.page:38(p)
 msgid ""
-"Allow the user to load images from network shares, scanners, and other more "
-"complicated sources."
+"Structuring an application for GNOME 3 means you will be using <link href="
+"\"http://developer.gnome.org/platform-overview/stable/gtk\";>GTK+</link>. The "
+"most important thing is to remember that the main window will only accept "
+"one widget. You must plan your structure accordingly (this example is using "
+"Gtk.Grid). A useful method is to draw out the main window and place every "
+"widget needed inside that box. By looking at an image of your future "
+"application it is easier to tell what are the relations between widgets. For "
+"example Gtk.Grid places your widgets in relation to other widgets, so after "
+"the first widget is in place, placing widgets can be done in relation to any "
+"widget on the grid."
 msgstr ""
-"ÎÏÎÏÏÎÏÏÎ ÏÏÎÎ ÏÏÎÏÏÎ ÎÎ ÏÎÏÏÏÎÎÎ ÎÎÎÏÎÎÏ ÎÏÏ ÏÏÎÏÎÏÎÎÏ ÎÎÎÎÎÎÏÎÏÎÎÏ ÎÏÏÎÎÏÎ "
-"ÏÎÏ ÎÎÎÎÎÎÏÏÎÏ, ÎÏÏ ÏÎÏÏÏÎÏ ÎÎÎ ÎÏÏ ÎÎÎÎÏ ÏÎÏÎÏÎÎÎÎÏ ÏÎÎÎÏ."
-
+"ÎÎÎÏÎÏÎÏ ÎÎÎ ÎÏÎÏÎÎÎÎ ÎÎÎ ÏÎ GNOME 3 ÏÎÎÎÎÎÎÎ ÏÎ ÏÏÎÏÎ ÏÎÏ <link "
+"href=\"http://developer.gnome.org/platform-overview/stable/gtk\";>GTK+</link>. "
+"ÎÎ ÏÎÎ ÏÎÎÎÎÏÎÎÏ ÏÏÎÎÎÎ ÎÎÎÎÎ ÎÎ ÎÏÎÏÏÎÏÏÎ ÏÏÎ ÏÎ ÎÏÏÎÎ ÏÎÏÎÎÏÏÎ ÎÎ "
+"ÎÏÎÎÎÏÎÎÎ ÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ. ÎÏÎÏÎÎ ÎÎ ÏÏÎÎÎÎÏÎÏÎ ÏÎ ÎÎÎÎ ÏÎÏ "
+"ÎÎÎÎÎÎÎ (ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎ Gtk.Grid). ÎÎÎ ÏÏÎÏÎÎÎ ÎÎÎÎÎÎÏ "
+"ÎÎÎÎÎ Î ÏÏÎÎÎÎÏÎ ÏÎÏ ÎÏÏÎÎÏ ÏÎÏÎÎÏÏÎÏ ÎÎÎ Î ÏÎÏÎÎÎÏÎÏÎ ÎÎÎÎ ÎÏÎÎÏÎÏÎÎÎÎÏ "
+"ÎÏÎÏÎÎÎÏ ÏÏÏÏÎÏÎÎÎÏ ÎÎÏÎ ÏÎ ÎÏÏÏ ÏÎ ÏÎÎÎÏÎÎ. ÎÎÎÏÏÎÏÎÏ ÎÎÎ ÎÎÎÏÎÎ ÏÎÏ "
+"ÎÎÎÎÎÎÏÎÎÎÏ ÏÎÏ ÎÏÎÏÎÎÎÎÏ ÎÎÎÎÎ ÎÏÎÎÎÏÏÎÏÎ ÎÎ ÏÎÎÏÎ ÏÎÎÎÏ ÎÎÎÎÎ ÎÎ ÏÏÎÏÎÎÏ "
+"ÎÎÏÎÎÏ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ. ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ Gtk.Grid ÏÎÏÎÎÎÏÎÎ ÏÎ ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ ÏÎÏ ÏÎ ÏÏÎÏÎ ÎÎ ÏÎ ÎÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ, ÎÏÏÎ ÎÎÏÎ ÏÎ ÏÎÏÎÎÎÏÎÏÎ "
+"ÏÎÏ ÏÏÏÏÎÏ ÎÏÎÏÎÎÎÏ ÏÏÏÏÎÏÎÎÎÏ ÏÏÎ ÎÎÏÎ ÏÎÏ, Î ÏÎÏÎÎÎÏÎÏÎ ÏÏÎ ÎÏÎÏÎÎÏÎ "
+"ÏÏÏÏÎÏÎÎÏÎ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÏÎÏÎ ÎÎ ÎÏÎÎÎÎÎÏÎÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÏÎ "
+"ÏÎÎÎÎÎ."
+
+#: C/weatherApp.js.page:42(p)
 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."
+"With many programming languages, all operations are run synchronously - you "
+"tell the program to do something, and it will wait until that action "
+"completes before proceeding. This is however bad for graphical user "
+"interfaces, as then the whole application will be frozen while the program "
+"waits for the operation. Going asynchronous (async) helps here. With async "
+"calls, your UI won't be blocked with any requests. Async calls make your "
+"application more flexible and better equipped to handle situations when "
+"calls take more time than expected or for some reason get jammed. Async "
+"calls can be used for example file system I/O and for slower calculations in "
+"the background."
 msgstr ""
-"ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎ <link href=\"http://library.gnome.org/devel/";
-"gio/unstable/\">GIO</link> ÎÎÎ ÎÎ ÎÎÎÎÏÎÏÎ ÎÎÏÎÏÎÏÎÏ ÎÏÏÎÎÏÎ ÎÎÎ ÏÎÏÏÎÎÎÎ, "
-"ÎÎÎ ÏÎ <link href=\"http://library.gnome.org/devel/gnome-scan/unstable/";
-"\">ÎÎÏÏÏÎ ÏÎÏ GNOME</link> ÎÎÎ ÏÎÏÏ ÏÎÏÏÏÎÏ."
-
+"ÎÎ ÏÎÎÎÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÏÎÎÎÏ ÎÎÏÏÏÎÏ, ÏÎÎÏ ÎÎ ÎÎÎÏÎÏÏÎÎÎÏ ÎÎÏÎÎÎÏÎÏÎÎ "
+"ÏÏÎÏÏÎÎÎ - ÎÎÏÎ ÏÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÎÎÎÎÎ ÎÎÏÎ ÎÎÎ ÎÎ ÏÎÏÎÎÎÎÎÏÎ ÎÎÏÏÎ ÎÏÏÎ Î "
+"ÏÏÎÎÎ ÎÎ ÎÎÎÎÎÎÏÏÎÎÎ ÏÏÎÎ ÎÎ ÏÏÎÎÏÎÏÎÏÎ. ÎÏÏÏ ÏÎÏÏ ÎÎÎÎÎ ÎÎÎÏ ÎÎÎ ÏÎ ÎÏÎÏÎÎÎ "
+"ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ, ÎÎÎÏÏ ÏÎÎ Î ÎÏÎÏÎÎÎÎ ÏÎÎÏÎÎÎ, ÎÎÏ ÏÎ ÏÏÏÎÏÎÎÎÎ ÏÎÏÎÎÎÎÎÎ ÏÎ "
+"ÎÎÎÏÎÏÏÎÎÎ. ÎÎÎÎÎÎÎÎÏÎÏ ÎÏÏÎÏÏÎÎÎ (async) ÎÎÎÎÎ ÎÎÏ. ÎÎ ÎÏÏÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ, "
+"ÏÎ UI ÏÎÏ ÎÎÎ ÎÎ ÏÏÎÏÏÎÎ ÎÎ ÎÎÏÎÏÎÎÏ. ÎÎ ÎÏÏÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ ÎÎÎÎÏÎ ÏÎÎ "
+"ÎÏÎÏÎÎÎÎ ÏÎÏ ÏÎÎ ÎÏÏÏÎÏÏÎ ÎÎÎ ÎÎÎÏÏÎÏÎ ÎÎÎÏÎÎÏÎÎÎÎ ÎÎÎ ÏÎÎÏÎÏÎÏ ÎÎÏÎÏÏÎÏÎÏÎ "
+"ÏÏÎÎ ÎÎ ÎÎÎÏÎÎÏ ÏÎÎÏÎÎÏÎ ÏÎÏÎÏÏÏÏÎÏÎ ÏÏÏÎÎ ÎÏÏ ÏÎ ÎÎÎÎÎÎÏÎÎÎÎ Î ÎÎÎ ÎÎÏÎÎÎ "
+"ÎÏÎÎ ÎÎÎÎÎÎÎ. ÎÎ ÎÏÏÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ ÎÏÎÏÎÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÏÎ ÎÎÎ "
+"ÏÎÏÎÎÎÎÎÎÎ ÎÎ ÎÏÏÎÎÎ ÏÏÏÏÎÎÎÏÎÏ I/O ÎÎÎ ÎÎÎ ÏÎÎ ÎÏÎÎÏÏ ÏÏÎÎÎÎÎÏÎÎÏÏ ÏÏÎ "
+"ÏÎÏÎÏÎÎÎÎÎ."
+
+#: C/weatherApp.js.page:45(p)
 msgid ""
-"A little bit more than a simple \"Hello world\" application - write an image "
-"viewer in GTK."
+"In this example we have to get data from geonames.org. While we do that we "
+"want the rest of our program to continue. If we wouldn't get any information "
+"from geonames.org for the lack of internet connection and this would be a "
+"synchronous application we would never get to the point where our main_quit"
+"() is processed correctly and the application would have to killed from "
+"Terminal."
 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"
-
+"ÎÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÎ ÎÎ ÏÎÏÎÏÎÎ ÎÎÎÎÎÎÎÎ ÎÏÏ ÏÎ geonames.org. ÎÎÏ "
+"ÎÎÎÎÏÎÎ ÎÏÏÏ ÎÎÎÎÏÎÎ ÏÎ ÏÏÏÎÎÎÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÏÏÎÎÏÎÏÎÎ. ÎÎÎ ÎÎÎ ÏÎÎÏÎÎÎÎ "
+"ÎÎÎÎÎ ÏÎÎÏÎÏÎÏÎÎ ÎÏÏ ÏÎ geonames.org ÎÏÎÏ ÎÎÎÎÎÏÎÏ ÏÏÎÎÎÏÎÏ ÎÎ ÏÎ ÎÎÎÎÎÎÏÏÎ "
+"ÎÎÎ ÎÏÏÏ ÎÏÎÎ ÎÎÎ ÏÏÎÏÏÎÎÎ ÎÏÎÏÎÎÎÎ ÎÎÎ ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÏÎÏÎ ÎÎ ÏÎÎÎ ÏÏÎ "
+"ÏÎÎÎÎÎ ÏÏÎÏ ÏÎ main_quit() ÏÏÎÎÏÎÎÎÎ ÏÏÏÏÎ ÎÎÎ Î ÎÏÎÏÎÎÎÎ ÎÎ ÎÏÏÎÏÎ ÎÎ "
+"ÎÎÎÎÏÏÎÎÎ ÎÏÏ ÏÎ ÏÎÏÎÎÏÎÎÏ."
+
+#: C/weatherApp.js.page:48(title)
+msgid "The different parts of the program"
+msgstr "ÎÎ ÎÎÎÏÎÏÎÏÎÎÎ ÎÎÏÎ ÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏ"
+
+#: C/vala.page:6(title)
+msgid "Vala"
+msgstr "Vala"
+
+#: C/vala.page:15(title)
+msgid "Tutorials, code samples and platform demos in Vala"
+msgstr "ÎÎÎÎÎÎÏÎ, ÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ ÎÎÎ ÏÎÏÎÏÏÎÎÏÎÎÏ ÏÎÎÏÏÏÏÎÎÏ ÏÏÎ Vala"
+
+#: C/translate.page:12(years) C/index.page:19(years)
+#: C/documentation.page:12(years) C/bug-filing.page:11(years)
+msgid "2011"
+msgstr "2011"
+
+#: C/translate.page:15(name)
+msgid "Michael Hill"
+msgstr "Michael Hill"
+
+#: C/translate.page:16(email)
+msgid "mdhillca gmail com"
+msgstr "mdhillca gmail com"
+
+#: C/translate.page:19(p) C/documentation.page:15(p) C/bug-filing.page:14(p)
+msgid "Creative Commons Share Alike 3.0"
+msgstr "Creative Commons Share Alike 3.0"
+
+#: C/translate.page:23(title)
+msgid "Help translate"
+msgstr "ÎÎÏÎÏÏÎÏÎ ÎÎÎÎÎÎÎÏ"
+
+#: C/translate.page:24(p)
 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."
+"The <app>Tutorial Demos</app> are being translated by a world-wide volunteer "
+"community. You are welcome to participate."
 msgstr ""
-"ÎÏÎÎÎÎÏÎ <gui>PyGTK (automake)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>Python</gui>, "
-"ÏÎÏÎÏÏÎ <gui>ÎÏÏÎÏÏÎ</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
-"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ <file>image-viewer</file> ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ "
-"ÏÎÏ ÏÎÎÎÎÎÏ."
+"ÎÎ <app>ÏÎÏÎÏÏÎÎÏÎÎÏ ÎÎÎÎÎÎÏÏÎ</app> ÎÎÏÎÏÏÎÎÎÎÏÎÎ ÎÏÏ ÎÎÎ ÏÎÎÎÏÏÎÎÎ "
+"ÎÎÎÎÏÏÎÏÎ ÎÎÎÎÎÎÏÏÎ. ÎÎÏÏÎ ÎÎÎÎÎÎÏÎÏÎÎÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÏÎÏÎ."
 
+#: C/translate.page:27(p)
 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>."
+"There are <link href=\"http://l10n.gnome.org/module/gnome-devel-docs/\";>many "
+"languages</link> for which translations are still needed."
 msgstr ""
-"ÎÎÎÎÏÏÎÏÏÎÎÏÎ ÏÏÎ ÎÏÎÎÎÏÎÎÏÎÎÎÏÎÏÎ ÏÎ <gui>ÎÏÎÏÎ ÏÎÏ GtkBuilder ÎÎÎ ÎÎÎÏÎÏÎ "
-"ÏÏÎÏÎ</gui> ÎÏÎÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÎÏÏÏ ÏÎ "
-"ÏÎÏÎÎÎÎÎÎÎ. ÎÎÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÏ ÏÎÏ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ, ÎÎÎÏÎ ÏÎ <link "
-"xref=\"guitar-tuner.py\">ÎÏÎÎÎÎÎÎ ÏÏÎÎÎÏÏÎ ÎÎÎÎÏÎÏ</link>."
+"ÎÏÎÏÏÎÏÎ <link href=\"http://l10n.gnome.org/module/gnome-devel-docs/\";>ÏÎÎÎÎÏ "
+"ÎÎÏÏÏÎÏ</link> ÎÎÎ ÏÎÏ ÎÏÎÎÎÏ ÎÏÎÎÏÎÏÎÏÎÎ ÎÎÏÎÏÏÎÏÎÎÏ."
 
+#: C/translate.page:30(p)
 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."
+"To start translating you will need to <link href=\"http://l10n.gnome.org";
+"\">create an account</link> and join the <link href=\"http://l10n.gnome.org/";
+"teams/\">translation team</link> for your language. This will give you the "
+"ability to upload new translations."
 msgstr ""
-"ÎÎÏÎÏÏÎ <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:"
+"ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎÏÎ ÎÎ ÎÎÏÎÏÏÎÎÎÏÎ ÏÏÎÏÎÎ ÎÎ <link "
+"href=\"http://l10n.gnome.org\";>ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎÎ ÎÎÎÎÏÎÎÏÎÏ</link> ÎÎÎ ÎÎ "
+"ÏÏÎÎÎÏÎÏÏÎÏÎ ÏÏÎÎ <link href=\"http://l10n.gnome.org/teams/\";>ÎÎÎÎÎ "
+"ÎÎÏÎÏÏÎÏÎÏ</link> ÏÎÏ ÎÎÏÏÏÎÏ ÏÎÏ. ÎÏÏÏ ÎÎ ÏÎÏ ÎÏÏÎÎ ÏÎÎ ÎÏÎÎÏÏÏÎÏÎ ÎÎ "
+"ÎÎÎÎÎÏÎÏÎ ÎÎÎÏ ÎÎÏÎÏÏÎÏÎÎÏ."
 
+#: C/translate.page:34(p)
 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."
+"You can chat with GNOME translators using <link href=\"https://cbe003.chat.";
+"mibbit.com/?url=irc%3A%2F%2Firc.gnome.org%2Fi18n\">irc</link>. People on the "
+"channel are located worldwide, so you may not get an immediate response as a "
+"result of timezone differences."
 msgstr ""
-"ÎÏÎ ÎÎÎÎÎÎ <code>__init__</code> ÏÎÏ ÎÎÎÏÎÏ <code>GUI</code> ÎÎÎÎÎÏÏÎÎÎÏÏÎ "
-"ÎÎÎ (ÎÎÎÎÎ) <code>Gtk.Window</code>, ÎÏÎÏÏÎ ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎ ÎÎÏÎ ÏÏÎÎÎÏÏÎ "
-"ÎÎÎ ÏÎÎÎ ÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÏÎÎ. ÎÎÎÎÎ ÏÎÎÏ "
-"ÎÏÎÏ, ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎ ÏÎ ÏÎÎÎÏÎ ÎÏÎÏÏÎÏÎ."
+"ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÎÏÎÏÎÏÎ ÎÎ ÎÎÏÎÏÏÎÏÏÎÏ ÏÎÏ GNOME ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ <link "
+"href=\"https://cbe003.chat.mibbit.com/?url=irc%3A%2F%2Firc.gnome.org%";
+"2Fi18n\">irc</link>. ÎÎÎÏÏÏÎÎ ÏÏÎ ÎÎÎÎÎÎ ÎÏÎÏÎÎÎÏÎÎ ÏÎÎÏÎÏ, ÎÏÏÎ ÎÏÎÏÎÎÏÎ ÎÎ "
+"ÏÎÏÎÏÎ ÎÎÎ ÎÎÎÏÎ ÎÏÎÎÏÎÏÎ ÏÏ ÎÏÎÏÎÎÎÏÎÎ ÏÏÎ ÎÎÎÏÎÏÏÎ ÏÏÎÏ."
 
+#: C/translate.page:37(p)
 msgid ""
-"Next, <code>destroy</code> is defined which just quits the application. It "
-"is called by the <code>destroy</code> signal connected above."
+"Alternatively, you can contact the Internationalization Team using their "
+"<link href=\"http://mail.gnome.org/mailman/listinfo/gnome-i18n\";>mailing "
+"list</link>."
 msgstr ""
-"ÎÎÏÎ, ÎÏÎÎÎÏÎÎ ÏÎ <code>destroy</code> ÏÎ ÎÏÎÎÎ ÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÏÎÎ ÏÎÎ "
-"ÎÏÎÏÎÎÎÎ. ÎÎÎÎÎÏÎÎ ÎÏÏ ÏÎ ÏÎÎÎ <code>destroy</code> ÏÎÏ ÏÏÎÎÎÏÎÏÎ ÏÎÏÎÏÎÎÏ."
+"ÎÎÎÎÎÎÎÏÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÎÎÎÏÎÎÏÎÏÎ ÎÎ ÏÎÎ ÎÎÎÎÎ ÎÎÎÎÎÎÏÎÎÎÏÎÏ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ <link href=\"http://mail.gnome.org/mailman/listinfo";
+"/gnome-i18n\">ÎÎÏÏÎ ÎÎÎÎÎÎÎÏÎÏÎÎÏ</link> ÏÎÏÏ."
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/treeview_simple_liststore.vala.page:22(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner-pipeline.png'; "
+#| "md5=5adc952909d92af5dae6954781b4ad5f"
+msgid ""
+"@@image: 'media/treeview_simple_liststore.png'; "
+"md5=2dc501a2b95b094da985d37b66aee90c"
+msgstr ""
+"@@image: 'media/treeview_simple_liststore.png'Â "
+"md5=2dc501a2b95b094da985d37b66aee90c"
 
-msgid "The rest of the file does initialisation for Gtk and displays the GUI."
+#: C/treeview_simple_liststore.vala.page:18(desc)
+msgid "A widget can display any TreeModel implementation (lists and trees)"
 msgstr ""
-"ÎÎ ÏÏÏÎÎÎÏÎ ÏÎÏ ÎÏÏÎÎÎÏ ÎÎÎÎÎ ÎÏÏÎÎÎÏÎÎÎÏÎ ÎÎÎ ÏÎ Gtk ÎÎÎ ÎÎÏÎÎÎÎÎÎ ÏÎ GUI."
+"ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÏÎÏÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÎÏÎÎÎÎÎÏÎÏÎ ÏÎÎÏÎÎÎÏÎ TreeModel "
+"(ÎÎÏÏÎÏ ÎÎÎ ÎÎÎÎÏÎ)"
 
+#: C/treeview_simple_liststore.vala.page:21(title)
+msgid "Simple Treeview with ListStore"
+msgstr "ÎÏÎÎ Treeview ÎÎ ListStore"
+
+#: C/treeview_simple_liststore.vala.page:23(p)
 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."
+"This TreeView displays a simple ListStore with the Selection \"changed\" "
+"signal connected."
 msgstr ""
-"Î ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ, ÎÏÏÏÎ ÎÎÎÎÎÎÏÏÎ ÏÎ ÏÎÏÏÎÏÎÏ "
-"<guiseq><gui>ÎÎÏÎÎÎÏÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq>. ÎÎ ÏÏÎÏÎÎ ÎÎ "
-"ÎÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎÎÎÎ ÏÎÏÎÎÏÏÎ."
-
+"ÎÏÏÎ Î TreeView ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÎÏÎÎ ListStore ÎÎ ÏÎ ÏÏÎÎÎÎÎÎÎ ÏÎÎÎ ÎÏÎÎÎÎÎÏ "
+"\"ÎÎÎÎÎÎÎÎÎ\"."
+
+#: C/treeview_simple_liststore.vala.page:30(link)
+msgid "Gtk.TreeView"
+msgstr "Gtk.TreeView"
+
+#: C/treeview_simple_liststore.vala.page:31(link)
+#: C/combobox.vala.page:28(link)
+msgid "Gtk.ListStore"
+msgstr "Gtk.ListStore"
+
+#: C/treeview_simple_liststore.vala.page:32(link)
+msgid "Gtk.TreeSelection"
+msgstr "Gtk.TreeSelection"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/toolbar.vala.page:22(None) C/toolbar.js.page:20(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+msgid "@@image: 'media/toolbar.png'; md5=f0350855eedf6343952b72d6d906f738"
+msgstr "@@image: 'media/toolbar.png'Â md5=f0350855eedf6343952b72d6d906f738"
+
+#: C/toolbar.vala.page:17(desc)
+msgid "A bar of buttons"
+msgstr "ÎÏÎÎÎÎ ÎÎÏÎÏÎÏÎ"
+
+#: C/toolbar.vala.page:20(title) C/toolbar.js.page:19(title)
+msgid "Toolbar widget"
+msgstr "ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÏÎÎÎÎÎÎÎÎÎÎÏ"
+
+#: C/toolbar.vala.page:23(p) C/toolbar.js.page:21(p)
 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:"
+"Toolbar can contain either text or stock icons. In this sample we use stock "
+"icons. This example has fullscreen functionality."
 msgstr ""
-"ÎÏ ÏÏÎÏÎÎÏÎÏÎÎ ÎÎÎ ÎÎÏÏÎ ÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎÏÎÎÏÏÎ ÏÎÎ "
-"ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎ ÏÏÎ ÎÎÎÎÎÎ <code>__init__</code> ÎÎÎÏÏÏ ÎÎÏÎ ÏÎ ÎÏÎÎÎÎ "
-"<code>window.connect_after</code>:"
+"Î ÎÏÎÎÎÎÎÎÎÎÎÎ ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÏÎ ÎÎÎÎÎÎÎ Î ÎÎÎÎÎÎÎÎÎ ÏÎÏÎÎÎÏÎÎÎÎÎÏ. ÎÎ "
+"ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÎÎÎÎÎÎÎÎÎ ÏÎÏÎÎÎÏÎÎÎÎÎÏ. ÎÏÏÏ ÏÎ "
+"ÏÎÏÎÎÎÎÎÎÎ ÎÏÎÎ ÎÎÎÏÎÏÏÎÎÎÏÏÎÏÎ ÏÎÎÏÎÏÏ ÎÎÏÎÎÏ."
 
+#: C/toolbar.vala.page:24(p) C/toolbar.js.page:22(p)
 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."
+"This example uses SimpleActions (window and app). App actions can easily be "
+"added the the app menu."
 msgstr ""
-"Î ÏÏÏÏÎ ÎÏÎÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ <code>Gtk.Box</code> ÏÎÏ ÎÎÎÎÎÎÎÏÎÎ <code>box</"
-"code> ÎÎÎ ÎÎ ÎÏÏÎÎÎÎÏ ÎÏÎÎÎÎÏ ÏÏÎÎÎÎÎÏÎ ÎÏÎ ÎÏÏ ÏÎÏ ÎÎÎÏÏÎÏÎÏ ÏÎÏ: ÏÎ "
-"<code>orientation</code> (ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÏ) ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎÎÏÎ (ÎÏÏÏÎ "
-"ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ-widgets ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎÏ), ÎÎÎ ÏÎ <code>spacing</"
-"code> (ÎÎÎÎÎÎÎÏÏÎÎÎ) ÎÎÎÎÎÏÎ ÏÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÎÏÎÎ ÏÏÎÎÎÏÏÎÎ "
-"ÏÏÎ 5 ÎÎÎÎÎÎÏÏÎÎÏÎÎÎ (pixels). Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ ÏÏÎÏÎÎÏÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÏÎ "
-"<code>Gtk.Box</code>."
-
+"ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎ SimpleActions (ÏÎÏÎÎÏÏÎ ÎÎÎ ÎÏÎÏÎÎÎÎ). ÎÎ "
+"ÎÎÎÏÎÎÎÎÏ ÏÎÏ ÎÏÎÏÎÎÎÎÏ ÎÏÎÏÎÏÎ ÎÏÎÎÎÎ ÎÎ ÏÏÎÏÏÎÎÎÏÎ ÏÏÎ ÎÎÎÎÏ ÏÎÏ "
+"ÎÏÎÏÎÎÎÎÏ."
+
+#: C/toolbar.vala.page:32(link) C/toolbar.js.page:30(link)
+msgid "Gtk.Toolbar"
+msgstr "ÎÏÎÎÎÎÎÎÎÎÎÎ Gtk"
+
+#: C/toolbar.vala.page:33(link)
+msgid "Gtk.Toolbutton"
+msgstr "ÎÎÏÎÏÎ ÎÏÎÎÎÎÎÎÏ Gtk"
+
+#: C/toolbar.vala.page:34(link)
+msgid "Gtk.Stock"
+msgstr "ÎÏÏÎÎÎÎ Gtk"
+
+#: C/toolbar.js.page:16(desc)
+msgid "A bar of tools"
+msgstr "ÎÏÎÎÎÎ ÎÏÎÎÎÎÎÏÎ"
+
+#: C/toolbar.js.page:31(link)
+msgid "Gtk.ToolButton"
+msgstr "ToolButton Gtk"
+
+#: C/toolbar.js.page:32(link)
+msgid "Gtk Stock items"
+msgstr "ÎÏÎÎÏÎÎÎ ÎÏÎÎÎÎÎÏÎÏ Gtk"
+
+#: C/toolbar.js.page:33(link)
+msgid "Gdk.WindowState"
+msgstr "Gdk.WindowState"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/togglebutton.vala.page:23(None) C/togglebutton.py.page:22(None)
+msgid "@@image: 'media/togglebutton.png'; md5=791e062613d4f9bd5936390b0aa18448"
+msgstr "@@image: 'media/togglebutton.png'Â md5=791e062613d4f9bd5936390b0aa18448"
+
+#: C/togglebutton.vala.page:19(desc) C/togglebutton.py.page:18(desc)
+msgid "A button which retains state"
+msgstr "ÎÎÎ ÎÎÏÎÏÎ ÏÎÏ ÎÏÎÏÎ ÎÎÏÎÏÏÎÏÎ"
+
+#: C/togglebutton.vala.page:22(title) C/togglebutton.py.page:21(title)
+msgid "ToggleButton"
+msgstr "ToggleButton"
+
+#: C/togglebutton.vala.page:24(p) C/togglebutton.py.page:23(p)
+msgid "When this ToggleButton is in an active state, the spinner spins."
+msgstr "ÎÏÎÎ ÎÏÏÏ ÏÎ ToggleButton ÎÎÎÎÎ ÎÎÎÏÎÏ, Î ÎÎÏÏÎÏÎÏ ÏÎÏÎÏÏÏÎÏÎÏÎÎ."
+
+#: C/togglebutton.vala.page:31(link)
+msgid "Gtk.ToggleButton"
+msgstr "Gtk.ToggleButton"
+
+#: C/togglebutton.py.page:13(name) C/textview.py.page:12(name)
+#: C/switch.py.page:15(name) C/statusbar.py.page:14(name)
+#: C/spinner.py.page:11(name) C/spinbutton.py.page:12(name)
+#: C/scrolledwindow.py.page:11(name) C/scale.py.page:12(name)
+#: C/radiobutton.py.page:14(name) C/progressbar.py.page:11(name)
+#: C/messagedialog.py.page:11(name) C/linkbutton.py.page:11(name)
+#: C/label.py.page:11(name) C/image.py.page:11(name) C/entry.py.page:11(name)
+#: C/dialog.py.page:11(name) C/checkbutton.py.page:11(name)
+#: C/button.py.page:11(name) C/aboutdialog.py.page:11(name)
+msgid "Marta Maria Casetti"
+msgstr "Marta Maria Casetti"
+
+#: C/togglebutton.py.page:14(email) C/textview.py.page:13(email)
+#: C/switch.py.page:16(email) C/statusbar.py.page:15(email)
+#: C/spinner.py.page:12(email) C/spinbutton.py.page:13(email)
+#: C/scrolledwindow.py.page:12(email) C/scale.py.page:13(email)
+#: C/radiobutton.py.page:15(email) C/progressbar.py.page:12(email)
+#: C/messagedialog.py.page:12(email) C/linkbutton.py.page:12(email)
+#: C/label.py.page:12(email) C/image.py.page:12(email)
+#: C/entry.py.page:12(email) C/dialog.py.page:12(email)
+#: C/checkbutton.py.page:12(email) C/button.py.page:12(email)
+#: C/aboutdialog.py.page:12(email)
+msgid "mmcasetti gmail com"
+msgstr "mmcasetti gmail com"
+
+#: C/togglebutton.py.page:30(link) C/checkbutton.py.page:30(link)
+msgid "GtkToggleButton"
+msgstr "GtkToggleButton"
+
+#: C/togglebutton.py.page:31(link)
+msgid "GtkWidget"
+msgstr "GtkWidget"
+
+#: C/togglebutton.py.page:32(link) C/spinner.py.page:28(link)
+msgid "GtkSpinner"
+msgstr "GtkSpinner"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/textview.py.page:21(None)
+#| msgid ""
+#| "@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+msgid "@@image: 'media/textview.png'; md5=049e859ed1af2d7c93d8cb5cfd9f7792"
+msgstr "@@image: 'media/textview.png'Â md5=049e859ed1af2d7c93d8cb5cfd9f7792"
+
+#: C/textview.py.page:17(desc)
+msgid "Widget that displays a GtkTextBuffer"
+msgstr "ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ ÎÎÏÎÎÎÎÎÎ ÎÎÎ GtkTextBuffer"
+
+#: C/textview.py.page:20(title)
+msgid "TextView"
+msgstr "TextView"
+
+#: C/textview.py.page:22(p)
+msgid "The text reads:"
+msgstr "ÎÎ ÎÎÎÎÎÎÎ ÎÎÎÎÎÎÎÎ:"
+
+#: C/textview.py.page:23(p)
+msgid "This is an example of Gtk.TextView."
+msgstr "ÎÏÏÏ ÎÎÎÎÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎÏ Gtk.TextView."
+
+#: C/textview.py.page:24(p)
+msgid "If we press \"enter\", we have a new line."
+msgstr "ÎÎÎ ÏÎÏÎÏÎÏÎ \"enter\", ÎÏÎÏÎÎ ÎÎÎ ÎÏÎÎÎÎ."
+
+#: C/textview.py.page:25(p)
 msgid ""
-"To add some widgets to the <code>Gtk.Box</code>, insert the following code "
-"directly below the <code>window.add (box)</code> line:"
+"But we can also have a new line if we write a long sentence (the text will "
+"wrap breaking lines between words)."
+msgstr ""
+"ÎÎÎÎ ÎÏÎÏÎÏÎÎ ÎÏÎÏÎÏ ÎÎ ÎÏÎÏÎÎ ÎÎÎ ÎÎÎ ÎÏÎÎÎÎ ÎÎÎ ÎÏÎÏÎÏÎÎ ÎÎÎ ÎÎÎÎÎÎ "
+"ÏÏÏÏÎÏÎ (ÏÎ ÎÎÎÎÎÎÎ ÎÎ ÎÎÎÎÎÏÎÏÎÎÎ ÎÎÎÎÏÏÏÎÎÏÎÏ ÏÎÏ ÎÏÎÎÎÎÏ ÎÎÏÎÎÏ ÏÏÎ "
+"ÎÎÎÎÏÎ)."
+
+#: C/textview.py.page:26(p)
+msgid "If we have a loooooooooooooooooooooooooooooooooooong"
+msgstr "ÎÎÎ ÎÏÎÏÎÎ ÎÎÎ ÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎ"
+
+#: C/textview.py.page:27(p)
+msgid "(that was long)"
+msgstr "(ÏÎÏ ÎÏÎÎ ÎÎÎÎÎÎ)"
+
+#: C/textview.py.page:28(p)
+msgid "word, an horizontal scrollbar will appear."
+msgstr "ÎÎÎÎ, ÎÎÎ ÎÏÎÎÏÎÏÎÎ ÎÏÎÎÎÎ ÎÏÎÎÏÎÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ."
+
+#: C/textview.py.page:35(link)
+msgid "GtkTextView"
+msgstr "GtkTextView"
+
+#: C/textview.py.page:36(link)
+msgid "GtkTextBuffer"
+msgstr "GtkTextBuffer"
+
+#: C/textview.py.page:37(link)
+msgid "GtkTextTags"
+msgstr "GtkTextTags"
+
+#: C/textview.py.page:38(link) C/scrolledwindow.py.page:28(link)
+msgid "GtkScrolledWindow"
+msgstr "GtkScrolledWindow"
+
+#: C/textview.py.page:39(link) C/scrolledwindow.py.page:29(link)
+#: C/scale.py.page:31(link)
+msgid "Standard Enumerations"
+msgstr "ÎÏÏÎÎÎÏ ÎÏÎÏÎÎÎÎÏÎÎÏ"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/switch.vala.page:24(None) C/switch.py.page:24(None)
+msgid "@@image: 'media/switch_off.png'; md5=211a2962708800697ad5373dcc86ad6d"
+msgstr "@@image: 'media/switch_off.png'Â md5=211a2962708800697ad5373dcc86ad6d"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/switch.vala.page:25(None) C/switch.py.page:25(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+msgid "@@image: 'media/switch_on.png'; md5=95e8769f758c2d95ace0fa8ecf30b29d"
+msgstr "@@image: 'media/switch_on.png'Â md5=95e8769f758c2d95ace0fa8ecf30b29d"
+
+#: C/switch.vala.page:20(desc) C/switch.py.page:20(desc)
+msgid "A \"light switch\" style toggle"
+msgstr "ÎÎÎ ÎÎÎÎÎÎÎÎ ÏÎÏÎÎÏÏÎÏÎÎÏ \"ÎÎÎÏÏÎÎÏ ÎÎÎÎÏÏÏÎ\""
+
+#: C/switch.vala.page:23(title) C/switch.py.page:23(title)
+msgid "Switch"
+msgstr "ÎÎÎÎÏÏÏÎÏ"
+
+#: C/switch.vala.page:27(p)
+msgid "This Switch toggles the title."
+msgstr "ÎÏÏÏÏ Î ÎÎÎÎÏÏÏÎÏ ÎÎÎÎÎÎÏÏÎÎ ÏÎÎ ÏÎÏÎÎ."
+
+#: C/switch.vala.page:34(link)
+msgid "Gtk.Switch"
+msgstr "Gtk.Switch"
+
+#: C/switch.py.page:27(p)
+msgid "This Switch makes the title appears and disappear."
+msgstr "ÎÏÏÏÏ Î ÎÎÎÎÏÏÏÎÏ ÎÎÎÎÎ ÏÎÎ ÏÎÏÎÎ ÎÎ ÎÎÏÎÎÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÎÎÏÎÎÎÎÎÏÎÎ."
+
+#: C/switch.py.page:34(link)
+msgid "GtkSwitch"
+msgstr "GtkSwitch"
+
+#: C/switch.py.page:35(link) C/label.c.page:36(link)
+msgid "GtkLabel"
+msgstr "GtkLabel"
+
+#: C/switch.py.page:36(link) C/radiobutton.py.page:32(link)
+msgid "GtkGrid"
+msgstr "GtkGrid"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/statusbar.vala.page:23(None) C/statusbar.py.page:23(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+msgid "@@image: 'media/statusbar.png'; md5=eb1aca55315d6cda57b12a5f36058ba8"
+msgstr "@@image: 'media/statusbar.png'Â md5=eb1aca55315d6cda57b12a5f36058ba8"
+
+#: C/statusbar.vala.page:19(desc) C/statusbar.py.page:19(desc)
+msgid "Report messages of minor importance to the user"
+msgstr "ÎÎÎÏÎÎÏÎ ÎÎÎÏÎÏÎÏ ÎÎÎÏÏÏÎÏÎÏ ÏÎÎÎÏÎÎÏ ÎÎÎ ÏÎÎ ÏÏÎÏÏÎ"
+
+#: C/statusbar.vala.page:22(title) C/statusbar.py.page:22(title)
+msgid "Statusbar"
+msgstr "ÎÏÎÎÎÎ ÎÎÏÎÏÏÎÏÎÏ"
+
+#: C/statusbar.vala.page:24(p)
+msgid "This statusbar tells you what's going on."
+msgstr "ÎÏÏÎ Î ÎÏÎÎÎÎ ÎÎÏÎÏÏÎÏÎÏ ÏÎÏ ÎÎÎÎ ÏÎ ÏÏÎÎÎÎÎÎÎ."
+
+#: C/statusbar.vala.page:31(link)
+msgid "Gtk.Statusbar"
+msgstr "Gtk.Statusbar"
+
+#: C/statusbar.py.page:24(p)
+msgid ""
+"This statusbar tells you if you click the button or if you press any key "
+"(and which key)."
+msgstr ""
+"ÎÏÏÎ Î ÎÏÎÎÎÎ ÎÎÏÎÏÏÎÏÎÏ ÏÎÏ ÎÎÎÎ ÎÎÎ ÏÎÏÎÏÎÏÎ ÏÎ ÎÎÏÎÏÎ Î ÎÎÎ ÏÎÏÎÏÎÏÎ "
+"ÎÏÎÎÎÎÎÏÎÏÎ ÎÎÎÎÎÎ (ÎÎÎ ÏÎÎÎ ÎÎÎÎÎÎ)."
+
+#: C/statusbar.py.page:31(link)
+msgid "GtkStatusbar"
+msgstr "GtkStatusbar"
+
+#: C/statusbar.py.page:32(link) C/progressbar.py.page:40(link)
+msgid "Gdk - Key Values"
+msgstr "ÎÎÎÎÏ ÎÎÎÎÎÎÎÏ Gdk"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/spinner.vala.page:20(None) C/spinner.py.page:20(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+msgid "@@image: 'media/spinner.png'; md5=d04f2d81f1d72c6c2f97e8729947dfed"
+msgstr "@@image: 'media/spinner.png'Â md5=d04f2d81f1d72c6c2f97e8729947dfed"
+
+#: C/spinner.vala.page:16(desc) C/spinner.py.page:16(desc)
+msgid "A spinner animation"
+msgstr "ÎÎÎÎÏÎ ÎÎÏÏÎÏÎ"
+
+#: C/spinner.vala.page:19(title) C/spinner.py.page:19(title)
+msgid "Spinner"
+msgstr "ÎÎÏÏÎÏÎÏ"
+
+#: C/spinner.vala.page:21(p) C/spinner.py.page:21(p)
+msgid "This Spinner is stopped and started by pressing the spacebar."
+msgstr "ÎÏÏÏÏ Î ÎÎÏÏÎÏÎÏ ÏÏÎÎÎÏÎ ÎÎÎ ÎÎÎÎÎÎ ÏÎÏÏÎÏÎÏ ÏÎ ÏÎÎÎÏÏÎ ÎÎÎÏÏÎÎÎÏÎÏ."
+
+#: C/spinner.vala.page:28(link)
+msgid "Gtk.Widget"
+msgstr "Gtk.Widget"
+
+#: C/spinner.vala.page:29(link)
+msgid "Gtk.Spinner"
+msgstr "Gtk.Spinner"
+
+#: C/spinner.vala.page:30(link)
+msgid "Gdk.keyval_name"
+msgstr "Gdk.keyval_name"
+
+#: C/spinner.py.page:29(link)
+msgid "Key Values"
+msgstr "ÎÎÎÎÏ ÎÎÎÎÎÎÎÏ"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/spinbutton.py.page:21(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+msgid "@@image: 'media/spinbutton.png'; md5=993cbb7d9bd271a329727a926195712a"
+msgstr "@@image: 'media/spinbutton.png'Â md5=993cbb7d9bd271a329727a926195712a"
+
+#: C/spinbutton.py.page:17(desc)
+msgid "Retrieve an integer or floating-point number from the user."
+msgstr "ÎÎÎÎÏÎÏÎ ÎÎÎÏÎÎÎÏ Î ÎÏÎÎÎÎÏ ÎÎÎÎÏÎÏ ÏÏÎÎÎÎÏÏÎÎÎÏ ÎÏÏ ÏÎÎ ÏÏÎÏÏÎ."
+
+#: C/spinbutton.py.page:20(title)
+msgid "SpinButton"
+msgstr "SpinButton"
+
+#: C/spinbutton.py.page:22(p)
+msgid "Choose a number, by entering it or by clicking on the -/+ buttons!"
+msgstr "ÎÏÎÎÎÎÏÎ ÎÎÎÎ ÎÏÎÎÎÏ, ÎÎÏÎÎÎÎÏÎÏ ÏÎÎ Î ÎÎ ÎÎÎÎ ÏÏÎ ÎÎÏÎÏÎÎ -/+!"
+
+#: C/spinbutton.py.page:29(link)
+msgid "GtkSpinButton"
+msgstr "GtkSpinButton"
+
+#: C/spinbutton.py.page:30(link) C/scale.py.page:30(link)
+msgid "GtkAdjustment"
+msgstr "GtkAdjustment"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/scrolledwindow.py.page:20(None)
+msgid ""
+"@@image: 'media/scrolledwindow.png'; md5=697bb3205d5c4fb0b4ea8db435843157"
+msgstr ""
+"@@image: 'media/scrolledwindow.png'Â md5=697bb3205d5c4fb0b4ea8db435843157"
+
+#: C/scrolledwindow.py.page:16(desc)
+msgid "Adds scrollbars to its child widget"
+msgstr "ÎÏÎÏÎÎÏÎÎ ÎÏÎÎÎÎÏ ÎÏÎÎÏÎÏ ÏÏÎ ÎÎÏÎÏÎ ÏÎÏ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ"
+
+#: C/scrolledwindow.py.page:19(title)
+msgid "ScrolledWindow"
+msgstr "ScrolledWindow"
+
+#: C/scrolledwindow.py.page:21(p)
+msgid "An image in a scrolled window."
+msgstr "ÎÎÎ ÎÎÎÏÎÎ ÏÎ ÎÏÎÎÏÎÎÎÎ ÏÎÏÎÎÏÏÎ."
+
+#: C/scrolledwindow.py.page:30(link) C/image.vala.page:32(link)
+#: C/image.c.page:33(link)
+msgid "GtkImage"
+msgstr "GtkImage"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/scale.py.page:21(None)
+msgid "@@image: 'media/scale.png'; md5=462c52a53b773cb9e8c62c646bf88452"
+msgstr "@@image: 'media/scale.png'Â md5=462c52a53b773cb9e8c62c646bf88452"
+
+#: C/scale.py.page:17(desc)
+msgid "A slider widget for selecting a value from a range"
+msgstr "ÎÎÎÏ ÎÎÎÏÎÎÏÎÏ ÎÏÎÏÎÎÎÏ ÏÏÏÏÎÏÎÎÎÏ ÎÎÎ ÎÏÎÎÎÎÎ ÏÎÎÎÏ ÎÏÏ ÎÎÎ ÏÎÏÎÎÏÎ"
+
+#: C/scale.py.page:20(title)
+msgid "Scale"
+msgstr "ÎÎÎÎÎÎÎ"
+
+#: C/scale.py.page:22(p)
+msgid "Slide the scales!"
+msgstr "ÎÎÎÏÎÎÏÎ ÏÏÎ ÎÎÎÎÎÎÏÎ!"
+
+#: C/scale.py.page:29(link)
+msgid "GtkScale"
+msgstr "GtkScale"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/record-collection.js.page:63(None)
+msgid ""
+"@@image: 'media/record-collection.png'; md5=2d645997687ed5aacd36aafafc16e072"
+msgstr ""
+"@@image: 'media/record-collection.png'Â md5=2d645997687ed5aacd36aafafc16e072"
+
+#: C/record-collection.js.page:9(desc)
+msgid "Create a small database application for ordering your music collection"
+msgstr ""
+"ÎÎÎÎÎÏÏÎÎÎ ÎÎÎÏ ÎÏÎÏÎÎÎÎÏ ÎÎÎÏÎÏ ÎÎÏÎÏ ÎÎÎÎÎÎÎÏÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎÏ ÎÎÏÏÎÎÎÏ "
+"ÏÎÏ ÏÏÎÎÎÎÎÏ"
+
+#: C/record-collection.js.page:13(name) C/image-viewer.vala.page:13(name)
+#: C/image-viewer.cpp.page:12(name) C/image-viewer.c.page:13(name)
+#: C/guitar-tuner.vala.page:13(name) C/guitar-tuner.py.page:13(name)
+#: C/guitar-tuner.cpp.page:12(name) C/guitar-tuner.c.page:13(name)
+#: C/getting-ready.page:11(name) C/audio-player.vala.page:13(name)
+msgid "GNOME Documentation Project"
+msgstr "ÎÏÎÎ ÏÎÎÎÎÏÎÏÏÎÏ GNOME"
+
+#: C/record-collection.js.page:14(email) C/index.page:8(email)
+#: C/image-viewer.vala.page:14(email) C/image-viewer.cpp.page:13(email)
+#: C/image-viewer.c.page:14(email) C/guitar-tuner.vala.page:14(email)
+#: C/guitar-tuner.py.page:14(email) C/guitar-tuner.cpp.page:13(email)
+#: C/guitar-tuner.c.page:14(email) C/getting-ready.page:12(email)
+#: C/audio-player.vala.page:14(email)
+msgid "gnome-doc-list gnome org"
+msgstr "gnome-doc-list gnome org"
+
+#: C/record-collection.js.page:17(name) C/photo-wall.c.page:16(name)
+#: C/magic-mirror.vala.page:17(name) C/index.page:17(name)
+#: C/image-viewer.vala.page:17(name) C/image-viewer.py.page:18(name)
+#: C/image-viewer.js.page:18(name) C/image-viewer.cpp.page:16(name)
+#: C/image-viewer.c.page:17(name) C/guitar-tuner.vala.page:17(name)
+#: C/guitar-tuner.py.page:17(name) C/guitar-tuner.cpp.page:16(name)
+#: C/guitar-tuner.c.page:17(name)
+msgid "Johannes Schmid"
+msgstr "Johannes Schmid"
+
+#: C/record-collection.js.page:18(email) C/photo-wall.c.page:17(email)
+#: C/magic-mirror.vala.page:18(email) C/index.page:18(email)
+#: C/image-viewer.vala.page:18(email) C/image-viewer.py.page:19(email)
+#: C/image-viewer.js.page:19(email) C/image-viewer.cpp.page:17(email)
+#: C/image-viewer.c.page:18(email) C/guitar-tuner.vala.page:18(email)
+#: C/guitar-tuner.py.page:18(email) C/guitar-tuner.cpp.page:17(email)
+#: C/guitar-tuner.c.page:18(email)
+msgid "jhs gnome org"
+msgstr "jhs gnome org"
+
+#: C/record-collection.js.page:22(title)
+msgid "3 Record Collection"
+msgstr "3 ÏÏÎÎÎÎÎ ÎÎÎÏÎÏÏÎ"
+
+#: C/record-collection.js.page:25(p) C/message-board.c.page:24(p)
+#: C/image-viewer.cpp.page:24(p) C/image-viewer.c.page:25(p)
+msgid "In this tutorial, you will learn:"
+msgstr "ÎÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ, ÎÎ ÎÎÎÎÏÎ:"
+
+#: C/record-collection.js.page:27(p)
+msgid "How to connect to a database using libgda"
+msgstr "ÎÏÏ ÎÎ ÏÏÎÎÎÎÎÎÏÎ ÎÎ ÎÎÎ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ libgda"
+
+#: C/record-collection.js.page:28(p)
+msgid "How to insert and browse records in a database table"
 msgstr ""
-"ÎÎÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÏÏÎ <code>Gtk.Box</"
-"code>, ÎÎÏÎÎÎÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÎÎÎ ÎÎÏÎÎÏÏ ÎÎÏÏ ÎÏÏ ÏÎÎ ÎÏÎÎÎÎ <code>window."
-"add (box)</code>:"
+"ÎÏÏ ÎÎ ÎÎÏÎÎÎÏÎ ÎÎÎ ÎÎ ÏÎÏÎÎÎÎÎÎÎÏÎ ÏÎ ÎÎÎÏÎÏÎÏ ÏÏÎÎ ÏÎÎÎÎÎ ÎÎÏÎÏ ÎÎÎÎÎÎÎÏÎ"
 
+#: C/record-collection.js.page:33(title) C/photo-wall.c.page:35(title)
+msgid "Introduction"
+msgstr "ÎÎÏÎÎÏÎÎ"
+
+#: C/record-collection.js.page:34(p)
 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."
+"This demo uses the Javascript language. We are going to demonstrate how to "
+"connect and use a database from a GTK program, by using the GDA (GNOME Data "
+"Access) library. Thus you also need this library installed."
 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."
+"ÎÏÏÎ Î ÏÎÏÎÏÏÎÎÏÎ ÏÏÎÏÎÎÎÏÎÎÎÎ ÏÎ ÎÎÏÏÏÎ Javascript. ÎÏÏÎÎÎÏÎÎ ÎÎ "
+"ÏÎÏÎÏÏÎÎÏÎÏÎÎ ÏÏÏ ÎÎ ÏÏÎÎÎÎÎÎÏÎ ÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ "
+"ÎÏÏ ÎÎÎ ÏÏÏÎÏÎÎÎÎ GTK ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÎÎÎÎÎÎÎÎÎÎ GDA (ÏÏÏÏÎÎÏÎ ÎÎÎÎÎÎÎÏÎ "
+"GNOME). ÎÏÏÎ ÏÏÎÎÎÎÏÏÎÏÏÎ ÎÏÎÏÎÏ ÎÏÏÎ ÏÎ ÎÎÎÎÎÎÎÎÎÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎ."
 
+#: C/record-collection.js.page:37(p)
 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>)."
+"GNOME Data Access (GDA) is library whose purpose is to provide universal "
+"access to different kinds and types of data sources. This goes from "
+"traditional relational database systems, to any imaginable kind of data "
+"source such as a mail server, a LDAP directory, etc. For more information, "
+"and for a full API and documentation, visit the <link href=\"http://library.";
+"gnome.org/devel/libgda/stable/\">GDA website</link>."
 msgstr ""
-"ÎÎ <code>pack_start</code> ÏÎÎÏÎÎÎ 4 ÏÎÏÎÎÎÏÏÎÏÏ: ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ "
-"(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>)."
+"Î ÏÏÏÏÎÎÏÎ ÎÎÎÎÎÎÎÏÎ GNOME (GDA) ÎÎÎÎÎ ÎÎÎÎÎÎÎÎÎÎ ÏÎÏ ÎÏÎÎÎÏ Î ÏÎÎÏÏÏ ÎÎÎÎÎ "
+"ÎÎ ÎÏÏÎÎ ÎÎÎÎÎÎ ÏÏÏÏÎÎÏÎ ÏÎ ÎÎÎÏÎÏÎÏÎÎÎ ÎÎÎÎ ÎÎÎ ÏÏÏÎÏÏ ÏÎÎÏÎ ÎÎÎÎÎÎÎÏÎ. "
+"ÎÏÏÏ ÎÎÎÎÎÎ ÎÏÏ ÏÎÏÎÎÎÏÎÎÎÎ ÏÏÎÏÎÎÎÎ ÏÏÏÏÎÎÎÏÎ ÎÎÏÎÏ ÎÎÎÎÎÎÎÏÎ, ÏÎ "
+"ÎÏÎÎÎÎÎÏÎÏÎ ÎÎÎÎÏ ÏÎÎÎÏ ÎÎÎÎÎÎÎÏÎ, ÏÏÏÏ ÎÎÏÏÎÏÎÏÎÏÎ ÎÎÎÎÎÎÎÏÎÏÎÎÏ, ÎÎÎÎ "
+"ÎÎÏÎÎÎÎÎ LDAP, ÎÎÏ. ÎÎÎ ÏÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÎÎÎ ÎÎÎ ÏÎÎÏÎÏ API ÎÎÎ "
+"ÏÎÎÎÎÏÎÏÏÎ, ÎÏÎÏÎÎÏÏÎÎÏÎ ÏÎÎ <link "
+"href=\"http://library.gnome.org/devel/libgda/stable/\";>ÎÏÏÏÏÎÏÎ GDA</link>."
+
+#: C/record-collection.js.page:40(p)
+msgid ""
+"Although a big part of the code is related to user interface (GUI), we are "
+"going to focus our tutorial on the database parts (we might mention other "
+"parts we think are relevant though). To know more about Javascript programs "
+"in GNOME, see the <link xref=\"image-viewer.js\">Image Viewer program</link> "
+"tutorial."
+msgstr ""
+"ÎÎ ÎÎÎ ÎÎÎ ÎÎÎÎÎÎ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÎÎ ÏÏÏÏÎÏÎÎÎÏÎÎ ÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ (GUI), "
+"ÏÏÏÎÎÎÏÎÎ ÎÎ ÎÏÏÎÎÏÎÏÎÎ ÏÎ ÎÎÎÎÎÎ ÎÎÏ ÏÏÎ ÎÎÏÎ ÏÎÏ ÎÎÏÎÏ ÎÎÎÎÎÎÎÏÎ (ÎÎ ÎÎÎ "
+"ÎÎ ÎÎÎÏÎÏÎÎÏÎ ÎÎÎÎ ÎÎÏÎ ÏÎÏ ÎÎÏÏÎÏÎÏÎÎ ÏÏÎÏÎÎÎ). ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎÏÎÏÏÏÏÎÏÎ "
+"ÎÎÎ ÏÎ ÏÏÎÎÏÎÎÎÎÏÎ JavaScript ÏÏÎ GNOME, ÎÎÎÏÎ ÏÎ ÎÎÎÎÎÎ <link xref=\"image-"
+"viewer.js\">ÏÏÏÎÏÎÎÎÎ ÏÏÎÎÎÎÎÎ ÎÎÎÏÎÎÏ</link>."
+
+#: C/record-collection.js.page:46(title) C/photo-wall.c.page:45(title)
+#: C/message-board.c.page:41(title) C/magic-mirror.vala.page:43(title)
+#: C/image-viewer.vala.page:50(title) C/image-viewer.py.page:44(title)
+#: C/image-viewer.js.page:45(title) C/image-viewer.cpp.page:34(title)
+#: C/image-viewer.c.page:35(title) C/guitar-tuner.py.page:41(title)
+#: C/guitar-tuner.cpp.page:40(title) C/guitar-tuner.c.page:41(title)
+msgid "Create a project in Anjuta"
+msgstr "ÎÎÎÎÎÏÏÎÎÏÏÎ ÎÎÎ ÎÏÎÎ ÎÎ ÏÎ Anjuta"
 
+#: C/record-collection.js.page:47(p) C/photo-wall.c.page:46(p)
+#: C/magic-mirror.vala.page:44(p) C/image-viewer.vala.page:51(p)
+#: C/image-viewer.py.page:45(p) C/image-viewer.js.page:46(p)
+#: C/image-viewer.cpp.page:35(p) C/image-viewer.c.page:36(p)
+#: C/guitar-tuner.vala.page:46(p) C/guitar-tuner.py.page:42(p)
+#: C/guitar-tuner.cpp.page:41(p) C/guitar-tuner.c.page:42(p)
 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."
+"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 ""
-"ÎÏÏÎÏ ÎÎ ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÏÎÏÏÎÎÎÎÏ ÎÎ ÏÎÏ ÎÏÎ ÏÏÏÏÎÏ, ÎÎÎÎ ÎÏÏÎ ÏÎ ÏÎÏÎ "
-"ÎÎÎÎÎÏÏÎÎÏÎ ÎÎÎ <code>Gtk.Button</code> ÎÎÎ ÏÎ ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ <code>box</"
-"code>. ÎÎÎÎÎÏÏÏÎ ÏÏÎ ÎÏÎÎÎÏÎÎ ÏÎÎ (ÎÎÏÏÎÏÎ) ÏÎÏÎÎÎÏÏÎ, ÏÎÎ <code>expand</"
-"code> ÏÎ <code>False</code>, ÎÎÏ ÎÎÏÎ ÎÏÎÏÏÎÎ <code>True</code> ÎÎÎ ÏÎ "
-"<code>Gtk.Image</code>. ÎÏÏÎ Î ÎÎÎÏÎÎ ÎÎ ÏÎÏÎÎ ÏÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ ÎÎÎ ÏÎ "
-"ÎÎÏÎÏÎÎ ÎÏÎÎ ÏÏÎ ÏÏÎÎÎÎÎÎÏÎÎ. ÎÏÎÎ ÎÎÎÎÏÏÎÏÎÎÎÏÎÎÏ ÏÎ ÏÎÏÎÎÏÏÎ, ÏÎ ÎÎÎÎÎÎÏ "
-"ÏÏÎ ÎÎÏÎÏÎÏÎ ÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎ ÎÎÎÎ, ÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ ÎÎ ÎÏÎÎÎÎÎ, "
-"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ ÏÎ ÏÏÏÎÎÎÏÎ ÏÎÏÎÎÏÏÎ."
+"ÎÏÎÎ ÎÎÎÎÎÎÏÎÏÎ ÎÎ ÏÏÎÎÏÎÎÎÎÏÎÎÎÏÎ, ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎ ÎÎÎÎÎÏÏÎÎÎ "
+"ÎÏÎÎ ÏÏÎ Anjuta. ÎÏÏÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÏÎ ÏÎÎ ÏÎ ÎÏÎÏÎÎÏÎÏÎ ÎÏÏÎÎÎ ÏÎÏ "
+"ÏÏÎÎÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎ ÎÏÎÏÏÎÏÎ. ÎÏÎÏÎÏ ÎÎ ÎÏÎÎ ÏÏÎÏÎÎÎ ÎÎ "
+"ÏÎ ÎÏÎÏÎÏÎ ÏÎÎ ÎÎÎÎ."
 
+#: C/record-collection.js.page:50(p) C/photo-wall.c.page:49(p)
+#: C/magic-mirror.vala.page:47(p) C/image-viewer.py.page:48(p)
+#: C/image-viewer.js.page:49(p) C/image-viewer.cpp.page:38(p)
+#: C/image-viewer.c.page:39(p) C/guitar-tuner.py.page:45(p)
+#: C/guitar-tuner.cpp.page:44(p) C/guitar-tuner.c.page:45(p)
 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."
+"Start Anjuta and click <guiseq><gui>File</gui><gui>New</gui><gui>Project</"
+"gui></guiseq> to open the project wizard."
 msgstr ""
-"ÎÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎÎ ÏÎÎÏ ÏÏÎ ÎÎÏÎÏÎ <gui>ÎÎÎÎÎÎÎ ÎÎÎÏÎÎÏâ</gui>, ÎÎÎÏ "
-"ÎÎÎÎÎÎÎÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÏÏÎ Î ÏÏÎÏÏÎÏ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ. ÎÏÎÎÏ "
-"ÎÎÎÎÎÎÎÎ, Î ÎÎÎÏÎÎ ÎÎ ÏÎÏÏÏÎÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÏÎ ÎÎÏÎÏÏÎÎÏÎ ÎÏÎÏÎÎÏ "
-"ÏÏÏÏÎÏÎÎÏ."
+"ÎÎÎÎÎÎÏÏÎ ÏÎ Anjuta ÎÎÎ ÏÎÏÎÏÏÎ "
+"<guiseq><gui>ÎÏÏÎÎÎ</gui><gui>ÎÎÎ</gui><gui>ÎÏÎÎ</gui></guiseq> ÎÎÎ ÎÎ "
+"ÎÎÎÎÎÎÏÎ ÏÎÎ ÎÎÎÎÏ ÏÎÏ ÎÏÎÎÏ."
+
+#: C/record-collection.js.page:53(p)
+#| 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."
+msgid ""
+"Choose <gui>Generic Javascript</gui> from the <gui>JS</gui> tab, click "
+"<gui>Forward</gui>, and fill-out your details on the next few pages. Use "
+"<file>record-collection</file> as project name and directory."
+msgstr ""
+"ÎÏÎÎÎÎÏÎ <gui>ÎÎÎÎÎÏ Javascript</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>JS</gui>, ÏÎÏÎÏÏÎ "
+"<gui>ÎÏÏÎÏÏÎ</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
+"ÎÎÎÎÏ ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÎÎÏÎÎÏÎÎÏ ÏÎ <file"
+">record-collection</file>."
+
+#: C/record-collection.js.page:56(p)
+#| 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."
+msgid ""
+"Click <gui>Finished</gui> and the project will be created for you. Open "
+"<file>src/main.js</file> from the <gui>Project</gui> or <gui>File</gui> "
+"tabs. It contains very basic example code."
+msgstr ""
+"ÎÎÏÎÏÏÎ <gui>ÏÎÎÎÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÎÏÎÏ. ÎÎÎÎÎÏÎ "
+"ÏÎ <file>src/main.js</file> ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ <gui>ÎÏÎÎ</gui> Î "
+"<gui>ÎÏÏÎÎÎ</gui>. ÎÎÏÎÎÎÎÎÎÎÎÎ ÏÎÎÏ ÎÏÎÏ ÏÎÏÎÎÎÎÎÎÎ ÎÏÎÎÎÎ."
+
+#: C/record-collection.js.page:62(title)
+msgid "Program Structure"
+msgstr "ÎÎÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏ"
 
+#: C/record-collection.js.page:64(p)
 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:"
+"This demo is a simple GTK application (with a single window) capable of "
+"inserting records into a database table as well as browsing all records of "
+"the table. The table has two fields: <code>id</code>, an integer, and "
+"<code>name</code>, a varchar. The first section (on the top) of the "
+"application allows you to insert a record into the table. The last section "
+"(bottom) allows you to see all the records of that table. Its content is "
+"refreshed every time a new record is inserted and on the application startup."
 msgstr ""
-"ÎÎ ÏÏÏÏÎ ÎÎÎÎ ÎÎÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÎÏ ÎÎÏÎÏÎÎÏ "
-"ÎÎ ÎÎÎ ÏÏÎÎÏÏÎÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signals handler), ÏÎÎ ÎÏÎÎÎ ÎÎÎÎÎÎÎÏÎÎ "
-"<code>on_open_clicked</code>. ÎÎÎÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÏÏ ÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ "
-"ÏÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎÎÎÎÏÏÎÎÎÏÎÎ <code>button = Gtk.Button()</code>:"
+"ÎÏÏÎ Î ÏÎÏÎÏÏÎÎÏÎ ÎÎÎÎÎ ÎÎÎ ÎÏÎÎ ÎÏÎÏÎÎÎÎ GTK (ÎÎ ÎÎÎÎÎÎÎÏ ÏÎÏÎÎÏÏÎ) ÎÎÎÎÏ "
+"ÎÎ ÎÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ ÏÏÎÎ ÏÎÎÎÎÎ ÎÎÏÎÏ ÎÎÎÎÎÎÎÏÎ ÎÎÎÏÏ ÎÎÎ ÏÎÏÎÎÎÎÏÎ ÏÎÏÎ ÏÏÎ "
+"ÎÎÎÏÎÏÏÎ ÏÎÏ ÏÎÎÎÎÎ. Î ÏÎÎÎÎÎÏ ÎÏÎÎ ÎÏÎ ÏÎÎÎÎ: <code>id</code>, ÎÎÎÏ "
+"ÎÎÎÏÎÎÎÏ ÎÎÎ <code>name</code>, ÎÎÎÎ varchar. Î ÏÏÏÏÎ ÎÎÏÏÎÏÎ (ÏÏÎÎ ÎÎÏÏÏÎ) "
+"ÏÎÏ ÎÏÎÏÎÎÎÎÏ ÎÏÎÏÏÎÏÎÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÎÎÎÏÎÏÎÏ ÏÏÎÎ ÏÎÎÎÎÎ. Î ÏÎÎÎÏÏÎÎÎ "
+"ÎÎÏÏÎÏÎ (ÏÏÎÎÎÎÎÏ) ÎÏÎÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÏÎÎÏ ÏÎÏ ÎÎÎÏÎÏÎÏ ÎÏÏÎÏ ÏÎÏ ÏÎÎÎÎÎ. ÎÎ "
+"ÏÎÏÎÎÏÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÏÎÎÏÎÎ ÎÎÎÎ ÏÎÏÎ ÏÎÏ ÎÎÎ ÎÎÎ ÎÎÎÏÎÏÎ ÎÎÏÎÎÎÏÎÎ ÎÎÎ "
+"ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÏÎÏ ÎÏÎÏÎÎÎÎÏ."
+
+#: C/record-collection.js.page:69(title)
+msgid "Starting the fun"
+msgstr "ÎÎÎÏÎÎ ÏÎÏ ÎÎÎÏÎÎÎÎÏÎÏ"
+
+#: C/record-collection.js.page:70(p)
+msgid "Let's start by examining the skeleton of the program:"
+msgstr "ÎÏ ÎÏÏÎÏÎÏÎÎ ÎÎÎÏÎÎÎÎÏÎÏ ÏÎÎ ÏÎÎÎÎÏÏ ÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏ:"
+
+#: C/record-collection.js.page:96(p)
+msgid ""
+"Lines 1â4: Initial imports. Pay special attention to line 3, which tells "
+"Javascript to import the GDA library, our focus in this tutorial."
+msgstr ""
+"ÎÏÎÎÎÎÏ 1-4: ÎÏÏÎÎÎÏ ÎÎÏÎÎÏÎÎÏ. ÎÏÏÏÎ ÎÎÎÎÎÏÎÏÎ ÏÏÎÏÎÏÎ ÏÏÎ ÎÏÎÎÎÎ 3, ÏÎÏ "
+"ÎÎÎÎ ÏÏÎ Javascript ÎÎ ÎÎÏÎÎÎÎ ÏÎ ÎÎÎÎÎÎÎÎÎÎ GDA, ÏÎ ÎÏÎÎÎÎÏÏÎ ÎÎÏ ÏÎ ÎÏÏÏ "
+"ÏÎ ÎÎÎÎÎÎ."
 
+#: C/record-collection.js.page:97(p)
 msgid ""
-"This will connect the <code>clicked</code> signal to <code>on_open_clicked</"
-"code> method that we will define below."
+"Lines 6â17: Define our <code>Demo</code> class. Pay special attention to "
+"lines 13â15, where we call 3 methods which will do the whole job. They will "
+"be detailed below."
 msgstr ""
-"ÎÏÏÏ ÎÎ ÏÏÎÎÎÏÎÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÏÎ ÎÎÎÎÎÎ "
-"<code>on_open_clicked</code> Î ÎÏÎÎÎ ÎÎ ÎÏÎÏÏÎÎ ÏÎÏÎÎÎÏÏ."
+"ÎÏÎÎÎÎÏ 6-17: ÎÏÎÏÏÎ ÏÎÎ ÎÎÎÏÎ ÎÎÏ <code>Demo</code>. ÎÏÏÏÎ ÎÎÎÎÎÏÎÏÎ "
+"ÏÏÎÏÎÏÎ ÏÏÎÏ ÎÏÎÎÎÎÏ 13-15, ÏÏÎÏ ÎÎÎÎÏÎÎ 3 ÎÎÎÏÎÎÏÏ ÏÎÏ ÎÎ ÎÎÎÎÏÎ ÏÎÎ ÏÎ "
+"ÎÎÏÎÎÎÎ. ÎÎÎÎÏÏÎÎÎ ÏÎÏÎÎÎÏÏ."
+
+#: C/record-collection.js.page:98(p)
+#| msgid "Run the application"
+msgid "Lines 19â23: Start the application."
+msgstr "ÎÏÎÎÎÎÏ 19-23: ÎÎÎÏÎÎ ÏÎÏ ÎÏÎÏÎÎÎÎÏ."
+
+#: C/record-collection.js.page:103(title)
+#| msgid "Run the application"
+msgid "Designing the application"
+msgstr "ÎÏÎÎÎÎÏÎÏÏ ÏÎÏ ÎÏÎÏÎÎÎÎÏ"
 
+#: C/record-collection.js.page:104(p)
 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:"
+"Let's take a look at the <code>setupWindow</code> method. It is responsible "
+"for creating the User Interface (UI). As UI is not our focus, we will "
+"explain only the relevant parts."
 msgstr ""
-"ÎÏÏÎ ÎÏÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎÎ ÏÎ ÎÎÎÎÎÎ <code>on_open_clicked</code>. "
-"ÎÎÏÎÎÎÏÎ ÏÎ ÎÎÏÎÎÏÎÎ ÏÏÎ ÎÎÎÏÎ <code>GUI</code>, ÎÎÏÎ ÏÎ ÎÎÎÎÎÎ "
-"<code>__init__</code>:"
+"ÎÏ ÏÎÎÎÏÎÎ ÎÎÎ ÎÎÏÎÎ ÏÏÎ ÎÎÎÎÎÎ <code>setupWindow</code>. ÎÎÎÎÎ ÏÏÎÏÎÏÎÎ ÎÎÎ "
+"ÏÎ ÎÎÎÎÎÏÏÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ (UI). ÎÎÎÏÏ Î UI ÎÎÎ ÎÎÎÎÎ ÏÎ ÎÏÎÎÎÎÏÏÎ "
+"ÎÎÏ, ÎÎ ÎÎÎÎÎÏÎÏÎÎ ÎÏÎÎ ÏÎ ÏÏÎÏÎÎÎ ÎÎÏÎ."
 
+#: C/record-collection.js.page:155(p)
 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."
+"Lines 22 and 27: Create the 2 entries (for the two fields) in which users "
+"will type something to get inserted in the database."
 msgstr ""
-"Î ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ <code>dialog</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎÎ ÎÎÎÎÎÎÎ "
-"<gui>Open</gui>, ÏÎÎ ÎÏÎÎÎ Î ÏÏÎÏÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÎÎ ÎÏÏÎÎÎ. "
-"ÎÏÎÎÎÏÎÎ ÏÏÎÎÏ ÎÎÎÏÏÎÏÎÏ: ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎÎÏÎÎÏ, ÏÎÎ ÎÎÎÏÎÎÎÎ (type) ÏÎÏ "
-"ÎÎÎÎÏÎÎÏ (ÎÎÎÎÎ ÎÎÎÎÎÎÎÏ ÂopenÂ, ÎÎÎÎ ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ "
-"<code>SAVE</code> ÎÎ ÎÎÎÎÎÎ ÎÎ ÎÏÎÎÎÎÎÏÏÎÏÎÎ ÎÎÎ ÎÏÏÎÎÎ)Â ÎÎÎ "
-"<code>transient_for</code>, ÏÏÎÏ ÎÏÎÎÎÎ ÏÎ ÎÎÎÎÎÏ ÏÎÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ."
+"ÎÏÎÎÎÎÏ 22 ÎÎÎ 27: ÎÎÎÎÎÏÏÎÎÎ ÏÏÎ 2 ÎÎÏÎÏÏÏÎÏÎÏÎ (ÎÎÎ ÏÎ ÎÏÎ ÏÎÎÎÎ) ÏÏÎ "
+"ÎÏÎÎÎ ÎÎ ÏÏÎÏÏÎÏ ÎÎ ÏÎÎÎÏÏÎÎÎÎÎÏÎÏÎ ÎÎÏÎ ÎÎÎ ÎÎ ÎÎÏÎÏÎÎÎ ÏÏÎ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ."
 
+#: C/record-collection.js.page:156(p)
+#| msgid ""
+#| "This will connect the <code>clicked</code> signal to "
+#| "<code>on_open_clicked</code> method that we will define below."
 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."
+"Lines 31â34: Create the Insert button. We connect its <code>clicked</code> "
+"signal to the <code>_insertClicked</code> private method of the class. This "
+"method is detailed below."
 msgstr ""
-"ÎÎ <code>dialog.run</code> ÎÎÏÎÎÎÎÎÎ ÏÎ ÎÎÎÎÎÎÎ <gui>ÎÎÎÎÎÎÎ</gui>. Î "
-"ÎÎÎÎÎÎÎÏ ÎÎ ÏÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎÂ ÏÏÎÎ ÎÎÎÎÎÎÎÎ, ÏÎ "
-"<code>dialog.run</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÎÎ ÏÎÎÎ <output>1</output> (ÎÎ "
-"ÎÏÎÏÏÏÎÏÎÎ <output>0</output> ÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎÎ <gui>ÎÎÏÏÏÏÎ</gui>). Î "
-"ÎÎÎÎÏÎÏ ÏÎÎÏ <code>if</code> ÎÎÎÎÏÎÎ ÎÎÎ ÎÏÏÏ."
+"ÎÏÎÎÎÎÏ 31-34: ÎÎÎÎÎÏÏÎÎÎ ÏÎÏ ÎÎÏÎÏÎÎÏ ÎÎÏÎÎÏÎÎÏ. ÎÏÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎ ÏÎÏ "
+"<code>clicked</code> ÏÏÎÎ ÎÎÎÏÏÎÎÎ ÎÎÎÎÎÎ <code>_insertClicked</code> ÏÎÏ "
+"ÎÎÎÏÎÏ. ÎÏÏÎ Î ÎÎÎÎÎÎÏ ÎÎÎÎÏÎÏÎÎ ÏÎÏÎÎÎÏÏ."
 
+#: C/record-collection.js.page:157(p)
 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!"
+"Line 39: Create the widget (<code>TextView</code>) where we will show the "
+"contents of the table."
 msgstr ""
-"ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÏÎÏÎ ÏÎÎÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÏÏÎÎÎÎÎÏÏÎ, ÎÏÏÏÎ ÎÎÎÎÎÎÏÏÎ ÎÎ ÏÎÎ "
-"ÎÎÏÎÎÎÏÎÏÎ. ÎÎÏ ÎÎÎÎÎ ÏÎ ÏÎÎÎÏÂ ÎÎÎ ÏÎÎÏÎÏ ÎÎÎ ÎÎÎÏÎÏÏÎÎÎÏ ÏÏÏÎÏÎÎÎÎ "
-"ÏÏÎÎÎÎÎÏ ÎÎÎÏÎÏÎ (ÎÎÎ ÎÎÎÏ ÎÎÎÏÏÏ ÎÎÎÎÏÏ ÏÎ Python ÎÎÎ Gtk) ÏÎ ÎÎÎÏÎÏÏÎ "
-"ÏÏÏÎÎ!"
+"ÎÏÎÎÎÎ 39: ÎÎÎÎÎÏÏÎÎÎ ÏÎÏ ÎÏÎÏÎÎÎÏ ÏÏÏÏÎÏÎÎÎÏ (<code>TextView</code>) ÏÏÎÏ "
+"ÎÎ ÎÎÏÎÎÎÏÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎÎÎÎ ÏÎÏ ÏÎÎÎÎÎ."
 
+#: C/record-collection.js.page:158(p)
 msgid ""
-"If you run into problems with the tutorial, compare your code with this "
-"<link href=\"image-viewer/image-viewer.py\">reference code</link>."
+"Line 44: Create the label where we will show the number of records in the "
+"table. Initially it's empty, it will be updated later."
 msgstr ""
-"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎÎ ÎÎÎÎÏ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ "
-"<link href=\"image-viewer/image-viewer.py\">ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+"ÎÏÎÎÎÎ 44: ÎÎÎÎÎÏÏÎÎÎ ÏÎÏ ÎÏÎÎÎÏÎÏ ÏÏÎÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ Î ÎÏÎÎÎÏÏ ÏÏÎ ÎÎÎÏÎÏÏÎ "
+"ÏÏÎÎ ÏÎÎÎÎÎ. ÎÏÏÎÎÎ ÎÎÎÎÎ ÎÎÎÎÎÏ, ÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÏÎÏÏÎÏÎ."
+
+#: C/record-collection.js.page:163(title)
+msgid "Connecting to and initializing the database"
+msgstr "ÎÏÎÎÎÏÎ ÎÎ ÎÎÎ ÎÏÏÎÎÎÏÎÎÎÏÎ ÏÎÏ ÎÎÏÎÏ ÎÎÎÎÎÎÎÏÎ"
 
-msgid "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+#: C/record-collection.js.page:164(p)
+msgid ""
+"The code which makes the connection to the database is in the "
+"<code>setupDatabase</code> method below:"
 msgstr ""
-"@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+"Î ÎÏÎÎÎÎÏ ÏÎÏ ÎÎÎÎÎ ÏÎ ÏÏÎÎÎÏÎ ÏÏÎ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ ÎÎÎÎÎ ÏÏÎÎ ÏÎÏÎÎÎÏÏ ÎÎÎÎÎÎ "
+"<code>setupDatabase</code>:"
 
+#: C/record-collection.js.page:181(p)
 msgid ""
-"@@image: 'media/guitar-tuner-glade.png'; md5=f6606525443ab2160f53a87a454364d0"
+"Lines 2â3: Create the GDA's <code>Connection</code> object. We must supply "
+"to its constructor some properties:"
 msgstr ""
-"@@image: 'media/guitar-tuner-glade.png'; md5=f6606525443ab2160f53a87a454364d0"
+"ÎÏÎÎÎÎÏ 2-3: ÎÎÎÎÎÏÏÎÎÎ ÏÎÏ ÎÎÏÎÎÎÎÎÎÎÎÏ ÏÎÏ GDA <code>Connection</code>. "
+"ÎÏÎÏÎÎ ÎÎ ÎÏÏÎÏÎÎ ÏÏÎÎ ÎÎÏÎÏÎÎÏÎÏÏÎ ÎÎÏÎÎÎÏ ÎÎÎÏÏÎÏÎÏ:"
 
+#: C/record-collection.js.page:184(p)
 msgid ""
-"@@image: 'media/guitar-tuner-pipeline.png'; "
-"md5=5adc952909d92af5dae6954781b4ad5f"
+"<code>provider</code>: One of GDA's supported providers. GDA supports "
+"SQLite, MySQL, PostgreSQL, Oracle and many others. For demo purposes we will "
+"use a SQLite database, as it comes installed by default in most "
+"distributions and it is simple to use (it just uses a file as a database)."
 msgstr ""
-"@@image: 'media/guitar-tuner-pipeline.png'; "
-"md5=5adc952909d92af5dae6954781b4ad5f"
+"<code>provider</code>: ÎÎÎÏ ÎÏÏ ÏÎÏÏ ÏÏÎÏÏÎÏÎÎÏÎÎÎÎÏÏ ÏÎÏÏÏÎÏÏ. ÎÎ GDA "
+"ÏÏÎÏÏÎÏÎÎÎÎ SQLite, MySQL, PostgreSQL, Oracle ÎÎÎ ÏÎÎÎÎÏÏ ÎÎÎÎÏÏ. ÎÎÎ ÏÎÏÏ "
+"ÏÎÎÏÎÏÏ ÏÎÏ ÏÎÏÎÏÏÎÎÏÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ SQLite, ÎÏÎÎÎÎ "
+"ÎÎÎÎÎÎÏÏÎÏÎÎ ÎÏÏ ÏÏÎÎÏÎÎÎÎÎ ÏÏÎÏ ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÎÎÎÎÎÎÏ ÎÎÎ ÎÎÎÎÎ ÎÏÎÎ ÏÏÎ "
+"ÏÏÎÏÎ (ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÏÎÎ ÎÎÎ ÎÏÏÎÎÎ ÏÏ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ)."
 
+#: C/record-collection.js.page:187(p)
 msgid ""
-"Use Gtk+ and GStreamer to build a simple guitar tuner application for GNOME. "
-"Shows off how to use the interface designer."
+"<code>cnc_string</code>: The connection string. It may change from provider "
+"to provider. The syntax for SQLite is: <code>DB_DIR=<var>PATH</var>;"
+"DB_NAME=<var>FILENAME</var></code>. In this demo we are accessing a database "
+"called gnome_demo in the user home dir (note the call to GLib's "
+"<code>get_home_dir</code> function)."
 msgstr ""
-"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ Gtk+ ÎÎÎ GStreamer ÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎ ÎÎÎ ÎÏÎÏ ÏÏÏÎÏÎÎÎÎ "
-"ÏÏÎÏÎÎÎÏÏÎ ÎÎÎÎÏÎÏ ÎÎÎ ÏÎ GNOME. ÎÎÎÎÎÎÎÎÏÎÎÏÎÏ ÏÏÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎ "
-"ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÏÎ."
+"<code>cnc_string</code>: Î ÏÏÎÎÎÎÎÏÎÎÏÎ ÏÏÎÎÎÏÎÏ. ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎÎÎ ÎÏÏ "
+"ÏÎÏÎÏÎ ÏÎ ÏÎÏÎÏÎ. Î ÏÏÎÏÎÎÎ ÎÎÎ ÏÎ SQLite ÎÎÎÎÎ: "
+"<code>DB_DIR=<var>PATH</var>;DB_NAME=<var>FILENAME</var></code>. ÎÎ ÎÏÏÎ ÏÎÎ "
+"ÏÎÏÎÏÏÎÎÏÎ ÏÏÎÏÏÎÎÎÎÎÏÎÎ ÎÎÎ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ ÏÎÏ ÎÎÎÎÏÎÎ gnome_demo ÏÏÎÎ "
+"ÏÏÎÏÏÏÎÎÏ ÎÎÏÎÎÎÎÎ ÏÏÎÏÏÎ (ÏÎÎÎÎÏÏÏÎ ÏÎÎ ÎÎÎÏÎ ÏÏÎ ÏÏÎÎÏÏÎÏÎ .GLib's "
+"<code>get_home_dir</code>)."
+
+#: C/record-collection.js.page:191(p)
+msgid ""
+"If the provider is not supported by GDA, or if the connection string is "
+"missing some element, line 2 will raise an exception. So, in real life we "
+"should handle it with JavaScript's statement <code>try</code>...<code>catch</"
+"code>."
+msgstr ""
+"ÎÎÎ Î ÏÎÏÎÏÎÏ ÎÎÎ ÏÏÎÏÏÎÏÎÎÎÏÎÎ ÎÏÏ GDA, Î ÎÎÎ ÎÎÎÏÎÎ ÏÏÎ ÏÏÎÎÎÎÎÏÎÎÏÎ "
+"ÏÏÎÎÎÏÎÏ ÎÎÏÎÎÎ ÏÏÎÎÏÎÎÎ, Î ÎÏÎÎÎÎ 2 ÎÎ ÎÎÎÎÏÎÎ ÎÎÎ ÎÎÎÎÏÎÏÎ. ÎÏÏÎ, ÏÏÎÎ "
+"ÏÏÎÎÎÎÏÎÎÎ ÎÏÎ ÎÎ ÏÎ ÏÎÎÏÎÏÏÎÏÎÎ ÎÎ ÎÎÎ ÏÏÏÏÎÏÎ ÏÎÏ JavaScript "
+"<code>try</code>...<code>catch</code>."
 
-msgid "Guitar Tuner"
-msgstr "ÎÏÎÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ"
+#: C/record-collection.js.page:195(p)
+msgid ""
+"Line 4: Open the connection. In the SQLite provider, if the database does "
+"not exist, it will be created in this step."
+msgstr ""
+"ÎÏÎÎÎÎ 4: ÎÎÎÎÎÎÎ ÏÎÏ ÏÏÎÎÎÏÎÏ. ÎÏÎÎ ÏÎÏÎÏÎ SQLite, ÎÎÎ Î ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ ÎÎÎ "
+"ÏÏÎÏÏÎÎ, ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÏÎ ÎÏÏÏ ÏÎ ÎÎÎÎ."
 
+#: C/record-collection.js.page:197(p)
 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:"
+"Lines 6â10: Try to do a simple select to check if the table exists (line 7). "
+"If it does not exist (because the database was just created), this command "
+"will raise an exception, which is handled by the <code>try</code>..."
+"<code>catch</code> block. If it is the case, we run the create table "
+"statement (line 9)."
 msgstr ""
-"ÎÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ, ÎÎ ÏÏÎÎÎÎÏÎÎ ÎÎÎ ÏÏÏÎÏÎÎÎÎ ÏÎÏ ÏÎÎÎÎÎ ÎÎÏÏÎÎÎÏÏ ÏÏÎÎÏÏ "
-"ÎÎÎ ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎÎÎÏÎ. ÎÎ ÎÎÎÎÏÎ ÎÎ:"
+"ÎÏÎÎÎÎÏ 6-10: ÎÏÎÏÏÎÎÎÏÏÎ ÎÎ ÎÎÎÎÏÎ ÎÎÎ ÎÏÎÎ ÎÏÎÎÎÎÎ ÎÎÎ ÎÎÎÎÏÎ ÏÏÎÏÎÎÏ ÏÎÏ "
+"ÏÎÎÎÎÎ (ÎÏÎÎÎÎ 7). ÎÎÎ ÎÎÎ ÏÏÎÏÏÎÎ (ÎÏÎÎÎÎ Î ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ ÎÏÎÎÏ "
+"ÎÎÎÎÎÏÏÎÎÎÎÎÎ), ÎÏÏÎ Î ÎÎÏÎÎÎ ÎÎ ÎÎÎÎÏÎÎ ÎÎÎ ÎÎÎÎÏÎÏÎ, ÏÎÏ ÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÏÏ "
+"ÏÎÎ ÎÎÎÎÎ <code>try</code>...<code>catch</code>. ÎÎÎ ÏÏÎÎÎÎÎÎÎ ÎÏÏÏ, "
+"ÏÏÎÏÎÏÎÎ ÏÎ ÎÎÎÎÎÏÏÎÎÎ ÏÏÏÏÎÏÎÏ ÏÎÎÎÎÎ (ÎÏÎÎÎÎ 9)."
 
-msgid "Set up a basic project in Anjuta"
-msgstr "ÎÎ ÏÏÎÎÏÎÎÏÎ ÎÎÎ ÎÎÏÎÎÏ ÎÏÎÎ ÏÏÎ Anjuta"
+#: C/record-collection.js.page:198(p)
+msgid ""
+"In order to run the SQL commands above we are using global GDA functions, "
+"<code>execute_select_command</code> and <code>execute_non_select_command</"
+"code>. They are simple to use, and just require two arguments: The "
+"<code>Connection</code> object and the SQL command to be parsed."
+msgstr ""
+"ÎÎÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÏÏÎ ÏÎÏÎÏÎÎÏ ÎÎÏÎÎÏÎ SQL ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎÏ ÎÎÎÎÎÎÏ "
+"ÏÏÎÎÏÏÎÏÎÎÏ GDA, <code>execute_select_command</code> ÎÎÎ "
+"<code>execute_non_select_command</code>. ÎÎÎÎÎ ÎÏÎÎÏ ÏÏÎ ÏÏÎÏÎ ÎÎÎ ÎÏÎÎÏÎÏÎ "
+"ÎÏÎÎ ÎÏÎ ÎÏÎÏÎÎÏÎ: ÎÎ ÎÎÏÎÎÎÎÎÎÎÎ <code>Connection</code> ÎÎÎ ÏÎÎ ÎÎÏÎÎÎ SQL "
+"ÎÎ ÎÎÎÎÏÎÎÎ. "
+
+#: C/record-collection.js.page:202(p)
+msgid "At this point we have the database set up, and are ready to use it."
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎÎ ÎÏÎÏÎÎ ÏÏÎÎÎÏÎÎ ÏÎ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ ÎÎÎ ÎÎÎÎÏÏÎ ÎÏÎÎÎÎÎ ÎÎ "
+"ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ."
 
-msgid "Create a simple GUI with Anjuta's UI designer"
-msgstr "ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÏÎÏ GUI ÎÎ ÏÎÎ ÏÏÎÎÎÎÏÏÎ UI ÏÎÏ Anjuta"
+#: C/record-collection.js.page:206(title)
+msgid "Selecting"
+msgstr "ÎÏÎÎÎÎÎ"
 
-msgid "Use GStreamer to play sounds"
-msgstr "ÎÏÎÏÎÎÎÏÎÎÎÎÏÎ ÏÎ GStreamer ÎÎÎ ÎÎ ÏÎÎÎÎÏÎ ÎÏÎÏÏ"
+#: C/record-collection.js.page:207(p)
+msgid ""
+"After connecting to the database, our demo's constructor calls the "
+"<code>selectData</code> method. It is responsible for getting all the "
+"records in the table and showing them on the <code>TextView</code> widget. "
+"Let's take a look at it:"
+msgstr ""
+"ÎÎÏÎ ÏÎÎ ÏÏÎÎÎÏÎ ÎÎ ÏÎ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ, Î ÎÎÏÎÏÎÎÏÎÏÏÎÏ ÏÎÏ ÏÎÏÎÏÏÎÎÏÎÏ ÎÎÏ "
+"ÎÎÎÎÎ ÏÎ ÎÎÎÎÎÎ<code>selectData</code>. ÎÎÎÎÎ ÏÏÎÏÎÏÎÎ ÎÎÎ ÏÎ ÎÎÏÎ ÏÎÏÎ ÏÏÎ "
+"ÎÎÎÏÎÏÏÎ ÏÏÎÎ ÏÎÎÎÎÎ ÎÎÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏÏ ÏÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ "
+"<code>TextView</code>. ÎÏ ÏÎÎÎÏÎÎ ÎÎÎ ÎÎÏÎÎ ÏÎ ÎÏÏÏ:"
 
-msgid "Create the user interface"
-msgstr "ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ"
+#: C/record-collection.js.page:228(p)
+msgid ""
+"Line 2: The <code>SELECT</code> command. We are using the global GDA's "
+"function <code>execute_select_command</code> for that. It returns a "
+"<code>DataModel</code> object, which is later used to retrieve the rows."
+msgstr ""
+"ÎÏÎÎÎÎ 2: Î ÎÎÏÎÎÎ <code>SELECT</code>. ÎÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÎÎÎÎÎÎ ÏÏÎÎÏÏÎÏÎ "
+"ÏÎÏ GDA <code>execute_select_command</code> ÎÎÎ ÎÏÏÏ. ÎÏÎÏÏÏÎÏÎÎ ÎÎÎ "
+"ÎÎÏÎÎÎÎÎÎÎÎ <code>DataModel</code>, ÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÏÎÏÏÎÏÎ ÎÎÎ "
+"ÎÎÎÎÏÎÏÎ ÏÏÎ ÎÏÎÎÎÏÎ."
 
+#: C/record-collection.js.page:229(p)
 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."
+"Line 3: Create an <code>Iter</code> object, which is used to iterate over "
+"the <code>DataModel</code>'s records."
 msgstr ""
-"ÎÎÎ ÏÎÏÎÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ (UI) ÏÎÏÎÎÏÎÏÎÎ ÏÏÎ ÎÏÏÎÎÎ GtkBuilder. ÎÎÎ "
-"ÎÎ ÎÏÎÎÎÏÎÎÏÏÎÎÏÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ, ÎÎÎÎÎÏÎ ÏÎ <file>src/guitar_tuner.ui</"
-"file>. ÎÎ ÎÏÎÎÎÎÏÎ ÏÏÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ. ÎÎ ÏÎÏÎÎÏÏÎ ÏÏÎÎÎÎÏÎÏ ÎÎÎÎÎ ÏÏÎ "
-"ÎÎÎÏÏÎÂ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÎÏ ÏÎÏÏ ÎÎÎÎÎ ÏÏÎ ÎÏÎÏÏÎÏÎ, Î "
-"ÏÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÏÎ ÎÎÎÎÎ."
+"ÎÏÎÎÎÎ 3: ÎÎÎÎÎÏÏÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎÏ <code>Iter</code>, ÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÎ "
+"ÎÏÎÎÎÎÎÏÎ ÏÏÎÏ ÎÎÎÏÎÏÎÏ ÏÎÏ <code>DataModel</code>."
 
+#: C/record-collection.js.page:230(p)
 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."
+"Line 7: Loop through all the records, fetching them with the help of the "
+"<code>Iter</code> object. At this point, the <code>iter</code> variable "
+"contains the actual, retrieved data. Its <code>move_next</code> method "
+"returns <code>false</code> when it reaches the last record."
 msgstr ""
-"Î ÎÎÎÏÎÎÎ ÎÎÎÎ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÏÎ Gtk+ ÎÏÎÎÎÏÎÎÏÎÎ ÏÎ ÎÎÏÏÎÎ ÎÎÎ ÏÎÎÎÎÎÏ. ÎÏ "
-"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÏ ÎÎÎ ÎÎÎÎÏÎ <gui>GtkButtonBox</gui> ÎÎÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎÎ "
-"ÎÎÎ <gui>GtkButtons</gui>, ÎÎÎ ÎÎÎ ÎÎÎÎ ÎÎÎ ÎÏÏ ÏÎÏ ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ."
+"ÎÏÎÎÎÎ 7: ÎÏÏÏÎÏ ÎÎÏÎ ÎÏÏ ÏÎÎÏ ÏÎÏ ÎÎÎÏÎÏÎÏ, ÏÎÏÎÎÎÏÎÏ ÏÎÏ ÎÎ ÏÎ ÎÎÎÎÎÎÎ ÏÎÏ "
+"ÎÎÏÎÎÎÎÎÎÎÎÏ <code>Iter</code>. ÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎÎ, Î ÎÎÏÎÎÎÎÏÎ "
+"<code>iter</code> ÏÎÏÎÎÏÎÎ ÏÎ ÎÎÎÏÎÎ ÎÎÎÎÏÎÎÎÎÎ ÎÎÎÎÎÎÎÎ. Î ÎÎÎÎÎÎÏ ÏÎÏ "
+"<code>move_next</code> ÎÏÎÏÏÏÎÏÎÎ <code>false</code> ÏÏÎÎ ÏÏÎÎÎÎ ÏÎÎ "
+"ÏÎÎÎÏÏÎÎÎ ÎÎÎÏÎÏÎ."
+
+#: C/record-collection.js.page:232(p)
+msgid "Lines 8â9: We do two things in each line:"
+msgstr "ÎÏÎÎÎÎÏ 8-9: ÎÎÎÎÏÎÎ ÎÏÎ ÏÏÎÎÎÎÏÎ ÏÎ ÎÎÎÎ ÎÏÎÎÎÎ:"
 
+#: C/record-collection.js.page:234(p)
 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."
+"Use <code>Iter</code>'s method <code>get_value_at</code>, which requires "
+"only one argument: the column number to retrieve, starting at 0. As our "
+"<code>SELECT</code> command returns only two columns, we are retrieving "
+"columns 0 and 1."
 msgstr ""
-"ÎÎÎÎÎÎÏÎ ÎÎÎ <gui>GtkButtonBox</gui> ÎÏÏ ÏÎ ÏÎÎÎÎ <gui>Container</gui> ÏÏÎÎ "
-"<gui>ÎÎÎÎÏÎ</gui> ÏÏÎ ÎÎÎÎÎ ÎÎÎ ÏÏÎÏÎÎÏÏÎ ÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎÎ ÎÎÏÏÎÎÎ "
-"<gui>ÎÎÎÏÏÎÏÎÏ</gui> ÎÎÎÎÏÎÏÏÎ ÏÎÎ ÎÏÎÎÎÏ ÏÏÎ ÏÏÎÎÏÎÎÏÎ ÏÎ 6 (ÎÎÎ ÏÎÏ ÎÎÎ "
-"ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ) ÎÎÎ ÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏ ÏÎ ÎÎÎÎÏÎ."
+"ÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÎÏ ÏÎÏ <code>Iter</code> <code>get_value_at</code>, ÏÎÏ "
+"ÎÏÎÎÏÎÎ ÎÏÎÎ ÎÎÎ ÏÏÎÏÎÎ: Î ÎÏÎÎÎÏÏ ÏÎÏ ÏÏÎÎÎÏ ÎÎÎ ÎÎÎÎÏÎÏÎ, ÏÎÏ ÎÎÎÎÎÎ ÎÏÏ "
+"0. ÎÎÎÏÏ Î ÎÎÏÎÎÎ ÎÎÏ <code>SELECT</code> ÎÏÎÏÏÏÎÏÎÎ ÎÏÎÎ ÎÏÎ ÏÏÎÎÎÏ, "
+"ÎÎÎÎÏÎÏÎÎ ÏÎÏ ÏÏÎÎÎÏ 0 ÎÎÎ 1."
 
+#: C/record-collection.js.page:235(p)
 msgid ""
-"Now, choose a <gui>GtkButton</gui> from the palette and put it into the "
-"first part of the box."
+"The method <code>get_value_at</code> returns the field in GLib's "
+"<code>GValue</code> format. A simple way to convert this format to a string "
+"is by using GDA's global function <code>value_stringify</code>. That's what "
+"we are doing here, and we store the results in the variables <code>id_field</"
+"code> and <code>name_field</code>."
 msgstr ""
-"ÎÏÏÎ, ÎÎÎÎÎÎÏÎ ÎÎÎ <gui>GtkButton</gui> ÎÏÏ ÏÎÎ ÏÎÎÎÏÎ ÎÎÎ ÎÎÎÏÎ ÏÎ ÏÏÎ "
-"ÏÏÏÏÎ ÎÎÏÎÏ ÏÎÏ ÎÎÏÏÎÎÏ."
+"Î ÎÎÎÎÎÎÏ <code>get_value_at</code> ÎÏÎÏÏÏÎÏÎÎ ÏÎ ÏÎÎÎÎ ÏÎ ÎÎÏÏÎ "
+"<code>GValue</code> ÏÎÏ GLib. ÎÎÎÏ ÎÏÎÏÏ ÏÏÏÏÎÏ ÎÎÏÎÏÏÎÏÎÏ ÎÏÏÎÏ ÏÎÏ ÎÎÏÏÎÏ "
+"ÏÎ ÏÏÎÎÎÎÎÏÎÎÏÎ ÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÎÎÎÎÎÎ ÏÏÎÎÏÏÎÏÎ ÏÎÏ GDA "
+"<code>value_stringify</code>. ÎÏÏÏ ÎÎÎÎÏÎÎ ÎÎÏ ÎÎÎ ÎÏÎÎÎÎÎÏÎÏÎÎ ÏÎ "
+"ÎÏÎÏÎÎÎÏÎÎÏÎ ÏÏÎÏ ÎÎÏÎÎÎÎÏÎÏ <code>id_field</code> ÎÎÎ "
+"<code>name_field</code>."
+
+#: C/record-collection.js.page:238(p)
+msgid ""
+"Line 11: Concatenate the two fields to make one text line, separated by "
+"<code>\"=&gt;\"</code>, and store it in the <code>text</code> variable."
+msgstr ""
+"ÎÏÎÎÎÎ 11: ÎÏÎÎÎÏÏÎ ÏÏÎ ÎÏÎ ÏÎÎÎÏÎ ÎÎÎ ÏÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎÏ ÎÏÎÎÎÎÏ ÎÎÎÎÎÎÎÏ, "
+"ÎÎÎÏÏÏÎÎÏÎÎÎÎÏ ÎÎ <code>\"=&gt;\"</code> ÎÎÎ ÎÏÎÎÎÎÎÏÏÎ ÏÎÏ ÏÏÎ ÎÎÏÎÎÎÎÏÎ "
+"<code>text</code>."
 
+#: C/record-collection.js.page:239(p)
 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."
+"Line 14: After the loop is finished, we have all the records formatted in "
+"the <code>text</code> variable. In this line we just set the contents of the "
+"<code>TextView</code> with that variable."
 msgstr ""
-"ÎÏÎÎÏÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎÏÎÎ ÎÏÎÎÎÎÎÎÎÎ, ÎÎÎÎÎÏÎ ÏÎÎ <gui>ÎÏÎÎÎÏÎ</gui> ÏÏÎÎ "
-"ÎÎÏÏÎÎÎ <gui>ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ</gui> ÏÎ <gui>E</gui>. ÎÏÏÎ ÎÎ ÎÎÎÎÎ Î ÏÎÎÎÎÎ "
-"ÏÎÏÎÎ Î."
+"ÎÏÎÎÎÎ 14: ÎÎÏÎ ÏÎ ÏÎÎÎÏ ÏÎÏ ÎÏÏÏÎÏ, ÎÏÎÏÎÎ ÏÎÎÏ ÏÎÏ ÎÎÏÏÎÏÎÎÎÎÎÎÎÏ ÎÎÎÏÎÏÎÏ "
+"ÏÏÎ ÎÎÏÎÎÎÎÏÎ <code>text</code>. ÎÎ ÎÏÏÎ ÏÎ ÎÏÎÎÎÎ ÎÏÎÎÎÏÎÎ ÎÏÎÎ ÏÎ "
+"ÏÎÏÎÎÏÏÎÎÎÎ ÏÎÏ <code>TextView</code> ÎÎ ÎÏÏÎ ÏÎ ÎÎÏÎÎÎÎÏÎ."
 
+#: C/record-collection.js.page:240(p)
 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>."
+"Line 15: Display the number of records in the table, making use of the "
+"<code>DataModel</code>'s <code>get_n_rows</code> method."
 msgstr ""
-"ÎÏÎÎÎÎÎÎÎÏÎ ÏÎ ÏÎÏÎÏÎÎÏ ÎÎÎÎÏÎ ÎÎÎ ÏÎ ÏÏÏÎÎÎÏÎ ÎÎÏÎÏÎÎ, ÏÏÎÏÎÎÏÏÎ ÏÎÏ "
-"ÎÏÏÎÎÎÎÏ 5 ÏÎÏÎÎÏ ÎÎ ÏÎ ÎÎÏÎÎÏÎ <em>A</em>, <em>D</em>, <em>G</em>, <em>B</"
-"em>, ÎÎÎ <em>e</em>."
+"ÎÏÎÎÎÎ 15: ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎÏ ÏÏÎ ÎÎÎÏÎÏÏÎ ÏÏÎÎ ÏÎÎÎÎÎ, ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ "
+"ÎÎÎÎÎÎ <code>get_n_rows</code> ÏÎÏ <code>DataModel</code>."
 
+#: C/record-collection.js.page:245(title)
+msgid "Inserting"
+msgstr "ÎÎÏÎÎÏÎÎ"
+
+#: C/record-collection.js.page:246(p)
 msgid ""
-"Save the UI design (by clicking <guiseq><gui>File</gui><gui>Save</gui></"
-"guiseq>) and keep it open."
+"OK, we know how to connect to a database and how to select rows from a "
+"table. Now it's time to do an <code>INSERT</code> on the table. Do you "
+"remember above, in the method <code>setupWindow</code> we connected the "
+"<gui>Insert</gui> button's <code>clicked</code> signal to the method "
+"<code>_insertClicked</code>? Let's see the implementation of this method."
+msgstr ""
+"ÎÎÏÎÎÎÎ, ÎÎÏÎÏÎÎ ÏÏÏ ÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÎÎ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ ÎÎÎ ÏÏÏ ÎÎ "
+"ÎÎÎÎÎÎÎÏÎÎ ÎÏÎÎÎÎÏ ÎÏÏ ÎÎÎÎ ÏÎÎÎÎÎ. ÎÏÏÎ ÎÎÎÎÎ ÏÏÎ ÎÎ ÎÎÎÎÏÎÎ ÎÎÎÎ "
+"<code>INSERT</code> ÏÏÎÎ ÏÎÎÎÎÎ. ÎÏÎÏÏÎÏÏÎ ÏÎÏÎÏÎÎÏ, ÏÏÎ ÎÎÎÎÎÎ "
+"<code>setupWindow</code> ÏÏÎÎÎÏÎÎÎ ÏÎ <gui>Insert</gui> ÏÎÏ ÎÎÏÎÏÎÎÏ ÎÎ ÏÎ "
+"ÏÎÎÎ <code>clicked</code> ÏÏÎ ÎÎÎÎÎÎ <code>_insertClicked</code>; ÎÏ ÎÎÏÎÎ "
+"ÏÎÎ ÏÎÎÏÎÎÎÏÎ ÎÏÏÎÏ ÏÎÏ ÎÎÎÏÎÎÏ."
+
+#: C/record-collection.js.page:267(p)
+msgid ""
+"We have learned how to use GDA's convenience functions "
+"<code>execute_select_command</code> and <code>execute_non_select_command</"
+"code> to quickly execute SQL commands on the database. GDA allows one to "
+"build a SQL statement indirectly, by using its <code>SqlBuilder</code> "
+"object. What are the benefits of this? GDA will generate the SQL statement "
+"dynamically, and it will be valid for the connection provider used (it will "
+"use the same SQL dialect the provider uses). Let's study the code:"
+msgstr ""
+"ÎÎÎÎÎÎ ÏÎ ÏÏÎÏÎ ÏÏÎ ÏÏÎÎÏÏÎÏÎÏÎ ÎÏÎÎÎÎÎÏ ÏÎÏ GDA "
+"<code>execute_select_command</code> ÎÎÎ "
+"<code>execute_non_select_command</code> ÎÎÎ ÎÏÎÎÎÏÎ ÎÎÏÎÎÎÏÎ ÎÎÏÎÎÏÎ SQL ÏÏÎ "
+"ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ. ÎÎ GDA ÎÏÎÏÏÎÏÎÎ ÏÎÎ ÎÎÏÎÏÎÎÏÎ ÎÎÎÏ ÏÏÏÏÎÏÎÏ SQL ÎÎÎÎÏÎ, "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÎÎÏÎÎÎÎÎÎÎÎ ÏÎÏ <code>SqlBuilder</code>. ÎÎÎÎ ÎÎÎÎÎ ÏÎ "
+"ÎÏÎÎÎ ÏÎÏ; GDA ÎÎ ÏÎÏÎÎÎÎ ÏÎÎ ÏÏÏÏÎÏÎ SQL ÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎ ÎÏÎÎÏÏÏÎÎÎ ÎÎÎ ÏÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÎÎÎ ÏÎÏÎÏÎ ÏÏÎÎÎÏÎÏ (ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎ ÎÎÎÎÎÎÏÎ SQL "
+"ÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎ Î ÏÎÏÎÏÎÏ). ÎÏ ÎÎÎÎÏÎÏÎÏÎÎ ÏÎÎ ÎÏÎÎÎÎ:"
+
+#: C/record-collection.js.page:271(p)
+msgid ""
+"Lines 2â3: Check if the user filled all the fields. The code for the private "
+"method <code>_validateFields</code> is really simple and you can read it in "
+"the full demo source code."
 msgstr ""
-"ÎÏÎÎÎÎÎÏÏÏÎ ÏÎ ÎÏÏÎÎÎ (ÏÎÏÏÎÏÎÏ <guiseq><gui>ÎÏÏÎÎÎ</gui><gui>ÎÏÎÎÎÎÎÏÏÎ</"
-"gui></guiseq>) ÎÎÎ ÎÏÎÏÎÏÏÎ ÏÎ ÎÎÎÎÏÏÏ."
+"ÎÏÎÎÎÎÏ 2-3: ÎÎÎÎÎÏÎ ÎÎÎ Î ÏÏÎÏÏÎÏ ÏÏÎÏÎÎÏÏÏÎ ÏÎÎ ÏÎ ÏÎÎÎÎ. Î ÎÏÎÎÎÎÏ ÎÎÎ "
+"ÏÎÎ ÎÎÎÏÏÎÎÎ ÎÎÎÎÎÎ <code>_validateFields</code> ÎÎÎÎÎ ÏÏÎÎÎÎÏÎÎÎ ÎÏÎÏÏ ÎÎÎ "
+"ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÎ ÎÎÎÎÎÏÎÏÎ ÏÏÎÎ ÏÎÎÏÎ ÏÎÏÎÏÏÎÎÏÎ ÏÎÎÎÎÎÏ ÎÏÎÎÎÎ."
 
+#: C/record-collection.js.page:272(p)
 msgid ""
-"For now, we'll leave the signal handler empty while we work on writing the "
-"code to produce sounds."
+"Line 5: The faster way of doing the <code>INSERT</code>. It's commented out "
+"as we want to show how to use the <code>SqlBuilder</code> object to build a "
+"SQL statement portable across databases."
 msgstr ""
-"ÎÎÎ ÏÎÎ ÏÏÎ, ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ ÎÎÎÎÎ ÎÎÎÏÏ ÎÎ ÎÏÏÎÎÎÎÎÏÎÎ ÎÎ "
-"ÏÎ ÎÏÎÏÎÎÎ ÏÎÏ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÏÎÏÎÎÎÎ ÏÎÏÏ ÎÏÎÏÏ."
+"ÎÏÎÎÎÎ 5: Î ÎÏÎÎÎÏÏÏÎÏÎÏ ÏÏÏÏÎÏ ÎÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ <code>INSERT</code>. "
+"ÎÏÎÎÎÎÎÎÏÎÎ, ÎÎÎÏÏ ÎÎÎÎÏÎÎ ÎÎ ÎÎÏÎÎÎÏÎÏÎÎ ÏÎ ÏÏÎÏÎ ÏÎÏ ÎÎÏÎÎÎÎÎÎÎÎÏ "
+"<code>SqlBuilder</code> ÎÎÎ ÎÎÏÎÏÎÎÏÎ ÎÎÎÏ ÏÏÏÏÎÏÎÏ SQL ÏÎÏÎÏÎÏ ÎÎÏÎ ÎÏÏ ÏÎÏ "
+"ÎÎÏÎÎÏ ÎÎÎÎÎÎÎÏÎ."
 
-msgid "GStreamer pipelines"
-msgstr "ÎÏÎÎÎÏÏÎÎÏ (pipeline) ÏÎÏ GStreamer"
+#: C/record-collection.js.page:273(p)
+msgid ""
+"Line 7: Create the <code>SqlBuilder</code> object. We must pass the type of "
+"statement we are going to build. It can be <code>SELECT</code>, "
+"<code>UPDATE</code>, <code>INSERT</code> or <code>DELETE</code>."
+msgstr ""
+"ÎÏÎÎÎÎ 7: ÎÎÎÎÎÏÏÎÎÎ ÏÎÏ ÎÎÏÎÎÎÎÎÎÎÎÏ <code>SqlBuilder</code>. ÎÏÎÏÎÎ ÎÎ "
+"ÏÎÏÎÏÎÏÎÎ ÏÎÎ ÏÏÏÎ ÏÎÏ ÏÏÏÏÎÏÎÏ ÏÎÏ ÏÏÏÎÎÎÏÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎÎ. ÎÏÎÏÎÎ ÎÎ "
+"ÎÎÎÎÎ <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code> Î "
+"<code>DELETE</code>."
 
+#: C/record-collection.js.page:274(p)
 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."
+"Line 8: Set the name of the table on which the built statement will operate "
+"(it will generate <code>INSERT INTO demo</code>)"
 msgstr ""
-"ÎÎ Gtreamer ÎÎÎÎÎ ÏÎ ÏÏÎÏÏÏÏÎÎÎ (framework) ÏÎÎÏÎÎÏÏÎ ÏÎÏ GNOME â ÎÏÎÏÎÎÏÎ "
-"ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÏÎ, ÎÏÎÎÏÎÏÎÏÎÏÎ, ÎÎÎ ÎÎ "
-"ÎÏÎÎÎÏÎÎÏÏÎÎÏÎ ÎÎÎÏÎÎ, ÎÏÎ, ÏÎÎÏ ÎÎÎÏÎÎ ÎÎÎ ÏÎ ÎÎÎÏÎ. ÎÎÏ, ÎÎ ÏÎ "
-"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÎÎ ÏÎÏÎÎÎÏÎÎ ÎÎÎÎÏ-ÏÏÏÎÏÏÎÏÎÏ ÏÏÎÏÎ."
+"ÎÏÎÎÎÎ 8: ÎÏÎÏÎÏÏ ÏÎÏ ÎÎÏÎÎÏÎÏ ÏÎÏ ÏÎÎÎÎÎ ÏÏÎÎ ÎÏÎÎÎ Î ÎÎÏÎÏÎÎÏÎÏÎÎÎÎ "
+"ÏÏÏÏÎÏÎ ÎÎ ÎÎÎÏÎÏÏÎÎÏÎÎ (ÎÎ ÏÎÏÎÎÎÎ <code>INSERT INTO demo</code>)"
 
+#: C/record-collection.js.page:275(p)
 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."
+"Lines 9â10: Set the fields and its values that will be part of the "
+"statement. The first argument is the field name (as in the table). The "
+"second one is the value for that field."
 msgstr ""
-"ÎÎÎÎÎÎÎÎÎÎÎÎ, ÏÎ GStreamer ÎÎÎÏÎÏÏÎÎÎ ÏÏ ÎÎÎÏ: ÎÎÎÎÎÏÏÎÎÎÏ ÎÎÎ <em>ÏÏÎÎÎÏÏÎ "
-"(pipeline)</em> ÏÎÏ ÏÎÏÎÎÏÎÎ ÎÎÎÏÎÏÎ ÎÏÎÎÎÏÎÎÎÏÎÎÎÎ ÏÏÎÎÏÎÎÎ ÏÎÏ ÏÎÎÎÎÎÎÏÎ "
-"ÎÏÏ ÏÎÎ <em>source</em> (ÏÎÎÎ) ÏÏÎ <em>sink</em> (ÎÎÎÎÎ). Î ÏÎÎÎ ÎÏÎÏÎÎ ÎÎ "
-"ÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ, ÎÎÎÏÎÎ, Î ÎÎÎ ÎÎÏÏÎÎÎÏ, ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, ÎÎÎ Î "
-"ÎÎÎÎÎÏ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ Î Î ÎÎÏÏÎ ÎÏÎÏ."
+"ÎÏÎÎÎÎÏ 9-10: ÎÏÎÏÎÏÏ ÏÏÎ ÏÎÎÎÏÎ ÎÎÎ ÏÏÎ ÏÎÎÏÎ ÏÎÏÏ ÏÎÏ ÎÎ ÎÎÎÎÎ ÏÎÎÎÎ ÏÎÏ "
+"ÏÏÏÏÎÏÎÏ. ÎÎ ÏÏÏÏÎ ÏÏÎÏÎÎ ÎÎÎÎÎ ÏÎ ÏÎÎÎÎ ÏÎÎÎÎÏ (ÏÏÏÏ ÏÏÎÎ ÏÎÎÎÎÎ). ÎÎ "
+"ÎÎÏÏÎÏÎ ÏÏÎÏÎÎ ÎÎÎÎÎ Î ÏÎÎÎ ÎÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎ."
 
+#: C/record-collection.js.page:276(p)
 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."
+"Line 11: Get the dynamically generated <code>Statement</code> object, which "
+"represents a SQL statement."
 msgstr ""
-"ÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎ ÎÎÎ ÏÏÎÎ ÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÏÎÏÏÎÏÎ ÎÎÎÏÎÏÎ ÏÎÎÏÏÎ ÎÎÎ "
-"ÎÎÏÎÏÏÎÏÎÏ ÎÎÎ ÏÎÎ ÏÎÎÏÎÏÎÏ ÎÏÎ, ÎÎÏÎÏÏÎÏÎÏ ÎÎÎÎÏÏ ÎÏÏÎÎÎÏ (format) ÎÎÎ "
-"ÎÎÎÏÎ. ÎÎÎÎ ÏÏÎÎÏÎÎÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ ÎÏÎÎ ÏÏÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ "
-"ÏÏÎÏÎÎÎÏÎÎÎÎÎÏÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎ ÏÏÎÏÎÏÎÏÎÏÎ."
+"ÎÏÎÎÎÎ 11: ÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎÎÏ ÎÎÏÎÎÎÎÎÎÎÎÏ "
+"<code>Statement</code>, ÏÎÏ ÎÎÏÎÏÏÎÏÏÏÎÏÎÎ ÎÎÎ ÏÏÏÏÎÏÎ SQL."
 
-msgid "An example GStreamer pipeline."
-msgstr "ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÎÎÏÏÎÏ GStreamer"
+#: C/record-collection.js.page:277(p)
+msgid "Line 12: Finally, execute the SQL statement (<code>INSERT</code>)."
+msgstr "ÎÏÎÎÎÎ 12: ÎÎÎÎÎÎ, ÎÎÏÎÎÎÏÎ ÏÎÏ ÏÏÏÏÎÏÎÏ SQL (<code>INSERT</code>)."
 
-msgid "Set up the pipeline"
-msgstr "ÎÏÎÎÎÏÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ (pipeline)"
+#: C/record-collection.js.page:278(p)
+msgid ""
+"Line 14: Clear the id and name fields on the screen. The code for the "
+"private method <code>_clearFields</code> is really simple and you can read "
+"it in the full demo source code."
+msgstr ""
+"ÎÏÎÎÎÎ 14: ÎÎÎÎÎÏÎ ÏÎÎ ÏÎÏÏÏÏÎÏÎ ÎÎÎ ÏÎÎÎÎ ÎÎÎÎÎÏÏÎ ÏÏÎÎ ÎÎÏÎÎ. Î ÎÏÎÎÎÎÏ "
+"ÎÎÎ ÏÎÎ ÎÎÎÏÏÎÎÎ ÎÎÎÎÎÎ <code>_validateFields</code> ÎÎÎÎÎ ÏÏÎÎÎÎÏÎÎÎ ÎÏÎÏÏ "
+"ÎÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÎ ÎÎÎÎÎÏÎÏÎ ÏÏÎÎ ÏÎÎÏÎ ÏÎÏÎÏÏÎÎÏÎ ÏÎÎÎÎÎÏ ÎÏÎÎÎÎ."
 
+#: C/record-collection.js.page:279(p)
 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>."
+"Line 15: Refresh the view on the screen by doing another <code>SELECT</code>."
 msgstr ""
-"ÎÎ ÎÏÏÏ ÏÎ ÎÏÎÏ ÏÎÏÎÎÎÎÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÏÎÎÎ ÏÎÏÎÎÏÎÎÏ ÏÏÎÏÎ, ÏÎÎ "
-"<code>audiotestsrc</code> ÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ ÏÏÎÎ ÏÏÎÎÏÎÎÎÎÎÎÎÎ "
-"ÏÏÏÎÎÏÎ ÎÏÎÏ ÏÎÏ ÏÏÏÏÎÎÎÏÎÏ, <code>autoaudiosink</code>. ÎÏÎÏÎÎ ÎÏÎÎ ÎÎ "
-"ÏÏÎÎÎÏÎÏÎÎ ÏÎÎ ÏÏÏÎÏÏÎÏÎ ÏÎÏ ÏÎÏÎÎÏÎÎÏ ÏÏÎÎÏÂ ÎÏÏÏ ÎÎÎÎÎ ÎÏÎÎÏÏ ÎÎÏÎ ÎÏÏ ÏÎÎ "
-"ÏÏÎÎÎÏÎ <code>freq</code> ÏÎÏ <code>audiotestsrc</code>."
+"ÎÏÎÎÎÎ 15: ÎÎÎÎÎÏÏÎ ÏÎÏ ÏÏÎÎÎÎÎÏ ÏÏÎÎ ÎÎÏÎÎ ÎÎÎÎÎÏÎÏ ÎÎÎ ÎÎÎÎ "
+"<code>SELECT</code>."
 
-msgid "Have the program automatically cycle through the notes."
-msgstr "ÎÎÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÏÎÏÎÎÎÎ ÎÏÏÏÎÎÏÎ ÎÎÏÎ ÎÏÏ ÏÎÏ ÎÏÏÎÏ."
-
-msgid "Make the program play recordings of real guitar strings being plucked."
+#: C/record-collection.js.page:281(p)
+msgid ""
+"You can also make use of parameters while building the statement. By using "
+"the <code>SqlBuilder</code> objects and parameters you are less subject to "
+"attacks like SQL injection. Check the <link href=\"http://library.gnome.org/";
+"devel/libgda/stable/\">GDA documentation</link> for more information about "
+"parameters."
 msgstr ""
-"ÎÎÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÎ ÎÏÎÎÏÎÏÎÏÎÎÏ ÎÏÏ ÎÎÎÎÎÎÎÏ ÏÎÏÎÎÏ ÎÎÎÎÏÎÏ "
-"ÏÎÏ ÎÏÎÏÎ ÎÎÏÎÏÎÎÎ."
+"ÎÏÎÏÎÎÏÎ ÎÏÎÏÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎÏÎÎÎÏÏÎÏÏ ÎÎÏ ÎÎÏÎÏÎÎÏÎÎÎÏÎ ÏÎÎ "
+"ÏÏÏÏÎÏÎ. ÎÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÎÎÏÎÎÎÎÎÎÎÎ <code>SqlBuilder</code> ÎÎÎ "
+"ÏÎÏÎÎÎÏÏÎÏÏ ÏÏÎÏÏÎÏÎÎ ÎÎÎÏÏÎÏÎÏ ÎÏÎÎÎÏÎÎÏ ÏÏÏÏ ÎÎÎÏÎÎÏ SQL. ÎÎÎÎÎÏÏÏÎ ÏÎ "
+"<link href=\"http://library.gnome.org/devel/libgda/stable/\";>ÏÎÎÎÎÏÎÏÏÎ "
+"GDA</link> ÎÎÎ ÏÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏÎÎÎ ÎÎ ÏÎÏ ÏÎÏÎÎÎÏÏÎÏÏ. "
+
+#: C/record-collection.js.page:285(title) C/image-viewer.py.page:220(title)
+#: C/image-viewer.js.page:306(title) C/guitar-tuner.py.page:223(title)
+msgid "Run the application"
+msgstr "ÎÏÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ"
 
+#: C/record-collection.js.page:286(p)
+#| 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!"
 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."
+"All of the code you need should now be in place, so try running the code. "
+"You now have a database for your record collection!"
 msgstr ""
-"ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÏÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎ ÏÏÎÎÎÏÏÎ "
-"GStreamer ÏÎÏ ÎÎ ÏÎÏ ÎÏÎÏÏÎÏÎÎ ÎÎ ÏÎÏÏÏÎÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÏÎ ÎÏÏÎÎÎ ÎÏÎÏ. "
-"ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ GStreamer <link href=\"http://gstreamer.";
-"freedesktop.org/documentation/plugins.html\">decoder ÎÎÎ demuxer</link> ÎÎ "
-"ÎÎÏÎ ÏÎÎ ÏÏÏÎ ÏÎÏ ÎÏÏÎÎÎÏ ÏÏÎ ÎÏÎÎÏÎÏÎÎÎÎÏÎ ÎÏÏÎ â ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎ MP3 "
-"ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏÎÎÎ ÏÏÎÎÏÎÎÎ ÎÏÏ ÏÎ Ogg Vorbis."
+"ÎÎÎÏ Î ÎÏÎÎÏÎÏÎÎÎÎÏ ÎÏÎÎÎÎÏ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÏÏÏÎ ÏÏÎ ÎÎÏÎ, ÎÏÏÎ ÏÏÎÏÏÎÎÎÏÏÎ "
+"ÎÎ ÏÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ. ÎÏÎÏÎ ÏÏÏÎ ÎÎÎ ÎÎÏÎ ÎÎÎÎÎÎÎÏÎ ÎÎÎ ÏÎ ÏÏÎÎÎÎÎÏ ÏÎÏ ÏÏÎ "
+"ÎÎÎÏÎÏÏÎ!"
+
+#: C/record-collection.js.page:290(title) C/photo-wall.c.page:378(title)
+#: C/magic-mirror.vala.page:143(title) C/image-viewer.vala.page:281(title)
+#: C/image-viewer.py.page:225(title) C/image-viewer.js.page:311(title)
+#: C/image-viewer.cpp.page:210(title) C/image-viewer.c.page:221(title)
+#: C/guitar-tuner.vala.page:253(title) C/guitar-tuner.py.page:228(title)
+#: C/guitar-tuner.js.page:233(title) C/guitar-tuner.cpp.page:255(title)
+#: C/guitar-tuner.c.page:256(title)
+msgid "Reference Implementation"
+msgstr "ÎÎÎÏÎÎÎÏÎ ÎÎÎÏÎÏÎÏ"
 
+#: C/record-collection.js.page:291(p)
+#| msgid ""
+#| "If you run into problems with the tutorial, compare your code with this "
+#| "<link href=\"guitar-tuner/guitar-tuner.py\">reference code</link>."
 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."
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"record-collection/record-collection.js\">reference code</link>."
 msgstr ""
-"ÎÏÏÏ ÏÏÎÎÎÏÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ ÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎÏÏ ÏÏÏÏÎÏÏ. ÎÏÏÏ "
-"ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÏÎÎÎÎÎÎÎÎÎ ÏÎ ÏÏÎÏÎ <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>."
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ "
+"ÏÎÎ <link href=\"record-collection/record-collection.js\">ÎÏÎÎÎÎ "
+"ÎÎÎÏÎÏÎÏ</link>."
 
-msgid "Automatically analyze notes that the user plays."
-msgstr "ÎÏÏÏÎÎÏÎ ÎÎÎÎÏÏÎ ÎÏÏÏÎ ÏÎÏ ÏÎÎÎÎÎ Î ÏÏÎÏÏÎÏ."
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/radiobutton.vala.page:23(None) C/radiobutton.py.page:23(None)
+msgid "@@image: 'media/radiobutton.png'; md5=d115460280d8e41493dd98054b5822a5"
+msgstr "@@image: 'media/radiobutton.png'Â md5=d115460280d8e41493dd98054b5822a5"
+
+#: C/radiobutton.vala.page:19(desc)
+msgid "A choice from multiple CheckButtons."
+msgstr "ÎÎÎ ÎÏÎÎÎÎÎ ÎÏÏ ÏÎÎÎÎÏÎÎ CheckButtons."
+
+#: C/radiobutton.vala.page:22(title) C/radiobutton.py.page:22(title)
+msgid "RadioButton"
+msgstr "RadioButton"
+
+#: C/radiobutton.vala.page:24(p)
+msgid "These RadioButtons report their activity in the terminal."
+msgstr "ÎÏÏÎ ÏÎ RadioButtons ÎÎÎÏÎÏÎÏÎ ÏÎÎ ÎÏÎÏÏÎÏÎÏÏÎÏÎ ÏÎÏÏ ÏÏÎ ÏÎÏÎÎÏÎÎÏ."
 
+#: C/radiobutton.vala.page:31(link)
+msgid "Gtk.RadioButton"
+msgstr "Gtk.RadioButton"
+
+#: C/radiobutton.py.page:19(desc)
+msgid "Mutually exclusive buttons."
+msgstr "ÎÎÎÎÎÎÎÎ ÎÏÎÎÎÎÎÏÎÎÎÎ ÎÎÏÎÏÎÎ."
+
+#: C/radiobutton.py.page:24(p)
 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?"
+"Three RadioButtons. You can see in the terminal if they are turned off or on."
 msgstr ""
-"ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎÏÏÏÏÎÎ ÎÎÎ ÎÎ ÎÏÎÎÏÎÏÎÏÎÏÎ ÎÏÏ ÎÏÏÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ "
-"ÏÎÎ <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> ÎÎ ÏÎÏ ÎÎÎÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÏÎ ÏÎÎÎ ÎÏÏÎ ÏÎÎÎÎÎ;"
+"ÎÏÎÎ RadioButtons. ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÏÎ ÏÏÎÎ ÏÎÏÎÎÏÎÎÏ ÎÎÎ ÎÎÎÎÎ ÎÎÎÎÎÏÎÎ Î "
+"ÎÎÎÏÎÎ."
+
+#: C/radiobutton.py.page:33(link)
+msgid "GtkRadioButton"
+msgstr "GtkRadioButton"
+
+#: C/py.page:6(title)
+msgid "Python"
+msgstr "Python"
+
+#: C/py.page:15(title)
+msgid "Tutorials, code samples and platform demos in Python"
+msgstr "ÎÎÎÎÎÎÏÎ, ÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ ÎÎÎ ÏÎÏÎÏÏÎÎÏÎÎÏ ÏÎÎÏÏÏÏÎÎÏ ÏÏÎ python"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/progressbar.vala.page:20(None) C/progressbar.py.page:20(None)
+msgid "@@image: 'media/progressbar.ogv'; md5=36deab3dd4b5be968828fa2ef416d612"
+msgstr "@@image: 'media/progressbar.ogv'Â md5=36deab3dd4b5be968828fa2ef416d612"
+
+#: C/progressbar.vala.page:16(desc)
+msgid "A widget which indicates progress visually"
+msgstr "ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ ÎÎÎÏÎÎÎ ÏÎÎ ÏÏÏÎÎÎ ÎÏÏÎÎÎ"
+
+#: C/progressbar.vala.page:19(title) C/progressbar.py.page:19(title)
+msgid "ProgressBar"
+msgstr "ProgressBar"
+
+#: C/progressbar.vala.page:24(p) C/progressbar.py.page:24(p)
+msgid "Pressing any key stops and starts this ProgressBar."
+msgstr "ÎÎÏÏÎÏÎÏ ÎÏÎÎÎÎÎÏÎÏÎ ÏÎÎÎÏÏÎ ÏÏÎÎÎÏÎ ÎÎÎ ÎÏÏÎÎÎÎ ÎÏÏÎ ÏÎ ProgressBar."
+
+#: C/progressbar.vala.page:31(p) C/progressbar.py.page:31(p)
+msgid "This ProgressBar is stopped and started by pressing any key."
+msgstr "ÎÏÏÎ Î ProgressBar ÏÏÎÎÎÏÎ ÎÎÎ ÎÎÎÎÎÎ ÏÎÏÏÎÏÎÏ ÎÏÎÎÎÎÎÏÎÏÎ ÏÎÎÎÏÏÎ."
+
+#: C/progressbar.vala.page:38(link) C/grid.py.page:33(link)
+#: C/grid.js.page:36(link)
+msgid "Gtk.ProgressBar"
+msgstr "Gtk.ProgressBar"
+
+#: C/progressbar.vala.page:39(link)
+msgid "GLib.Timeout"
+msgstr "GLib.Timeout"
+
+#: C/progressbar.vala.page:40(link)
+msgid "GLib.Source"
+msgstr "GLib.Source"
+
+#: C/progressbar.vala.page:41(link)
+msgid "Gtk.Widget.key_press_event"
+msgstr "Gtk.Widget.key_press_event"
+
+#: C/progressbar.py.page:16(desc)
+msgid "A widget which indicates progress visually."
+msgstr "ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ ÎÎÎÏÎÎÎ ÏÎÎ ÏÏÏÎÎÎ ÎÏÏÎÎÎ."
+
+#: C/progressbar.py.page:38(link)
+msgid "GtkProgressBar"
+msgstr "GtkProgressBar"
+
+#: C/progressbar.py.page:39(link)
+msgid "GLib - The Main Event Loop"
+msgstr "GLib - Î ÎÏÏÎÎÏ ÎÏÏÏÎÏ ÏÏÎÎÎÎÏÎÏ"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/photo-wall.c.page:77(None)
+msgid "@@image: 'media/photo-wall.png'; md5=f19590d97e8ec029cda3c44b769c11cd"
+msgstr "@@image: 'media/photo-wall.png'Â md5=f19590d97e8ec029cda3c44b769c11cd"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/photo-wall.c.page:80(None)
+msgid ""
+"@@image: 'media/photo-wall-focused.png'; md5=9f1ceecf3a28c1e468597b093a10cbae"
+msgstr ""
+"@@image: 'media/photo-wall-focused.png'Â "
+"md5=9f1ceecf3a28c1e468597b093a10cbae"
 
-msgid "Basic knowledge of the Python programming language"
-msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Python"
+#: C/photo-wall.c.page:8(desc)
+msgid "A Clutter image viewer"
+msgstr "ÎÎÎÏ ÏÏÎÎÎÎÎÎÏ ÎÎÎÏÎÎÏ Clutter"
+
+#: C/photo-wall.c.page:12(name)
+msgid "Chris KÃhl"
+msgstr "Chris KÃhl"
+
+#: C/photo-wall.c.page:13(email)
+msgid "chrisk openismus com"
+msgstr "chrisk openismus com"
 
+#: C/photo-wall.c.page:21(title)
+msgid "Photo Wall"
+msgstr "ÎÏÏÎÎÏÎÏÎÎÏÏ ÏÎÎÏÎÏ"
+
+#: C/photo-wall.c.page:24(p)
 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."
+"For this example we will build a simple image viewer using Clutter. You will "
+"learn:"
 msgstr ""
-"ÎÏÎÎÎÎÏÎ <gui>PyGTK (automake)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>Python</gui>, "
-"ÏÎÏÎÏÏÎ <gui>ÎÏÏÎÏÏÎ</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
-"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÏÎÎÎÎÎÏ ÏÎ <file>guitar-"
-"tuner</file>."
+"ÎÎÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎÎ ÎÎÎÎ ÎÏÎÏ ÏÏÎÎÎÎÎÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ Clutter. ÎÎ ÎÎÎÎÏÎ:"
 
-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:"
+#: C/photo-wall.c.page:26(p)
+msgid "How to size and position <code>ClutterActor</code>s"
+msgstr "ÎÏÎÎÎÎÎÏÏÎ ÎÎÎ ÏÎÏÎÎÎÏÎÏÎ ÏÎÏ <code>ClutterActor</code>s"
+
+#: C/photo-wall.c.page:27(p)
+msgid "How to place an image in a <code>ClutterActor</code>"
+msgstr "ÎÏÏ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎ ÎÎÎ ÎÎÎÏÎÎ ÏÎ ÎÎÎ <code>ClutterActor</code>"
+
+#: C/photo-wall.c.page:28(p)
+msgid "How to do simple transitions using Clutter's animation framework"
 msgstr ""
-"ÎÎÏÎÏÏÎ <gui>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ. ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ "
-"<gui>ÎÏÎÎ</gui> Î <gui>ÎÏÏÎÎÎ</gui> ÎÎÎÎÎÏÎ ÏÎ <file>src/guitar_tuner.py</"
-"file>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ ÏÎÏ ÎÏÎÎÎÎÏ:"
+"ÎÏÏ ÎÎ ÎÎÎÎÏÎ ÎÏÎÎÏ ÎÎÏÎÎÎÏÎÎÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÏÎÎÎÎÏÏ ÎÎÎÎÏÎÏ ÏÎÏ "
+"Clutter"
 
-msgid "Run the code for the first time"
-msgstr "ÎÎÏÎÎÎÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÎÎÎ ÏÏÏÏÎ ÏÎÏÎ"
+#: C/photo-wall.c.page:29(p)
+msgid "How to make <code>ClutterActor</code>s respond to mouse events"
+msgstr ""
+"ÎÏÏ ÎÎ ÎÎÎÎÏÎ ÏÎ <code>ClutterActor</code>s ÎÎ ÎÏÎÎÏÎÏÎÎ ÏÏÎ ÏÏÎÎÎÎÏÎ ÏÎÏ "
+"ÏÎÎÏÎÎÎÎÏ"
+
+#: C/photo-wall.c.page:30(p)
+msgid "How to get file names from a directory"
+msgstr "ÎÏÏ ÎÎ ÏÎÏÎÏÎ ÎÎÏÎÎÏÎ ÎÏÏÎÎÎÏ ÎÏÏ ÎÎÎÎ ÎÎÏÎÎÎÎÎ"
 
+#: C/photo-wall.c.page:36(p)
 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:"
+"Clutter is a library for creating dynamic user interfaces using OpenGL for "
+"hardware acceleration. This example demonstates a small, but central, part "
+"of the Clutter library to create a simple but attractive image viewing "
+"program."
 msgstr ""
-"Î ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÏÎÎÎÎÏ ÏÏÎ ÎÏÏÎÎÎ ÎÎÎÎÎ ÏÏÏÏÏÏÎ ÎÏÎÎÎÎ. ÎÎÏÏÏÎÎÎ ÎÎÎ (ÎÎÎÏ) "
-"ÏÎÏÎÎÏÏÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ ÏÎÏÎÎÏÎÏÎÏ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÎÎÎÎÎ. "
-"ÎÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏÏÎÏÎ ÏÎÎ ÎÎÏÏÂ ÏÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎ ÎÎÏÏÎ ÎÎ "
-"ÎÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎ ÎÎÏÎÎÎ:"
+"Clutter ÎÎÎÎÎ ÎÎÎ ÎÎÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÏÎÎÎÎÎÏÎ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ OpenGL ÎÎÎ ÎÏÎÏÎÏÏÎÏÎ ÏÎÎÎÎÏ. ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÎÎÎÏÎÎÎ "
+"ÎÎÎ ÎÎÎÏÏ, ÎÎÎÎ ÎÎÎÏÏÎÎÏ, ÏÎÎÎÎ ÏÎÏ Clutter ÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÏÏ ÎÏÎÎÏ ÎÎÎÎ "
+"ÎÎÎÏÏÏÎÎÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏ ÏÏÎÎÎÎÎÏ ÎÎÎÏÎÎÏ."
 
+#: C/photo-wall.c.page:39(p)
 msgid ""
-"The <code>import</code> lines at the top include the tell Python to load the "
-"user interface and system libraries needed."
+"To help us reach our goal we will be utilising a few other common pieces of "
+"GLib as well. Most importantly, we'll use one <code>GSList</code>, a singly-"
+"linked list, to hold our <code>ClutterActor</code>s and another one for file "
+"path names. We will also use <code>GDir</code>, a utility for working with "
+"directories, to access our image directory and gather file paths."
 msgstr ""
-"ÎÎ ÎÏÎÎÎÎÏ <code>import</code> ÏÏÎÎ ÎÏÏÎ ÎÎÎÎ ÏÏÎÎ Python ÎÎ ÏÎÏÏÏÏÎÎ ÏÎÏ "
-"ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏ ÏÏÏÏÎÎÎÏÎÏ ÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÏÎÏ ÏÏÎÎÎÎÎÎÏÎÎ."
-
+"ÎÎÎ ÎÎ ÎÎÎÎÎÎÎÏÎÎ ÎÎ ÏÏÎÏÎÏÎÎ ÏÎÎ ÏÏÏÏÎ ÎÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎÎ ÎÎÎÎ "
+"ÎÎÎÎÎ ÎÎÎÎÎÏÎÎ ÏÎÏ GLib ÎÏÎÏÎÏ. ÎÎ ÏÎÎ ÏÎÎÎÎÏÎÎÏ, ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ "
+"<code>GSList</code>, ÎÎÎ ÎÎÎÎÎÎÎÎ ÏÏÎÎÎÎÎÎÎ ÎÎÏÏÎ, ÎÎÎ ÎÎ ÎÏÎÏÎÏÎÏÎÎ ÏÎ "
+"<code>ClutterActor</code>s ÎÎÏ ÎÎÎ ÎÎÎ ÎÎÎÎ ÎÎÎ ÎÎÏÎÎÏÎ ÎÎÎÎÏÎÎÎÏ ÎÏÏÎÎÎÏ. "
+"ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÏÎÏÎÏ <code>GDir</code>, ÎÎÎ ÎÎÎÎÎÎÎ ÎÎÎ ÎÏÎÎÏÎÎ ÎÎ "
+"ÎÎÏÎÎÏÎÎÏÏ, ÎÎÎ ÏÏÎÏÏÎÎÎÏÎ ÏÎÏ ÎÎÏÎÎÏÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ ÎÎÏ ÎÎÎ ÎÎ "
+"ÏÏÎÎÎÎÏÏÏÏÎÏÎÎ ÏÎÏ ÎÎÎÎÏÎÎÎÏ ÏÎÏ ÎÏÏÎÎÎÏ."
+
+#: C/photo-wall.c.page:52(p)
+#| 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."
 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."
+"Choose <gui>Gtk+ (simple)</gui> from the <gui>C</gui> tab, click "
+"<gui>Continue</gui>, and fill out your details on the next few pages. Use "
+"<file>photo-wall</file> as project name and directory."
 msgstr ""
-"ÎÎÎ ÎÎÎÏÎ ÎÏÎÎÎÏÎÎ ÏÏÎ ÎÎ ÎÎÎÎÎ Î ÎÏÏÎÎ (main) ÎÎÎÏÎ ÎÎÎ ÏÎ ÏÏÏÎÏÎÎÎÎ. ÎÏÎÎ "
-"ÎÎÎÎÎÎ <code>__init__</code> ÏÎ ÎÏÏÎÎ ÏÎÏÎÎÏÏÎ ÏÎÏÏÏÎÎÏÎÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ "
-"GtkBuilder (<file>src/guitar-tuner.ui</file>) ÎÎÎ ÏÎ ÏÎÎÎÏÎ ÏÏÎÎÎÎÎÏÎÎ."
-
+"ÎÏÎÎÎÎÏÎ <gui>Gtk+ (ÎÏÎÏ)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>C</gui>, ÏÎÏÎÏÏÎ "
+"<gui>ÏÏÎÎÏÎÎÎ</gui> ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ ÎÎÎÎÏ "
+"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ <file>photo-wall</file> ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ "
+"ÏÎÏ ÎÎÏÎÎÏÎÎÏ."
+
+#: C/photo-wall.c.page:55(p)
+#| 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>."
 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."
+"Make sure that <gui>Use GtkBuilder for user interface</gui> is disabled as "
+"we will create the UI manually in this tutorial. Check the <link xref="
+"\"guitar-tuner.c\">Guitar-Tuner</link> tutorial using the interface builder."
 msgstr ""
-"ÎÏÎÎÎÎÎÏÎÏ ÏÎÎÎÏÎ ÎÎÏÏÎ ÏÎ ÎÎÏÎ ÎÎ ÎÎÎÎÏÎÎÎÏÎ ÏÎ ÎÎ ÏÏÎÎÎÎ ÏÏÎÎ ÎÎÎ ÎÎÏÎÏÎ "
-"ÏÎÏÎÎÎÎ, Î ÏÏÎÎ ÏÏÎÎÎÎ ÎÎÏÎÎÎ ÎÎÎÎ ÏÎÎÎ. ÎÎÏ, ÎÎÎÎÎÏÎÎ Î ÎÎÎÎÎÎÏ "
-"<code>destroy</code> ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÏÎ ÏÎÏÎÎÏÏÎ (ÎÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ)."
+"ÎÎÎÎÏÏÎÏÏÎÎÏÎ ÏÏÎ Î <gui>ÏÏÎÏÎ ÏÎÏ GtkBuilder ÎÎÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ</gui> ÎÎÎÎÎ "
+"ÎÎÎÎÎÏÎÎ ÎÏÎÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎ UI ÏÎÎÏÎÎÎÎÎÏÎ ÏÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ. ÎÎÎÎÎÏÏÏÎ "
+"ÏÎ ÎÎÎÎÎÎ <link xref=\"guitar-tuner.c\">ÏÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ</link> "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ ÎÎÏÎÏÎÎÏÎÏÏÎ ÎÎÎÏÎÏÎÏ."
 
+#: C/photo-wall.c.page:60(p)
 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."
+"Enable <gui>Configure external packages</gui>. On the next page, select "
+"<em>clutter-1.0</em> from the list to include the Clutter library in your "
+"project."
 msgstr ""
-"Î ÏÏÎÎÏÏÎÏÎ <code>main</code> ÎÎÏÎÎÎÎÏÎÎ ÏÏÎÎÎÎÎÏÎÏÎÎÎÎ ÎÏÎÎÏ ÏÏÎÎÎÏÎ ÎÎÎ "
-"ÏÏÏÎÏÎÎÎÎ ÏÎ Python. ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÏÎÎÏÎÏÎ (instance) ÏÎÏ ÎÏÏÎÎÏ ÎÎÎÏÎÏ "
-"main ÎÎÎ ÎÎÎÎÎÎÎÎ ÏÎÎ ÎÏÏÎÎ ÎÏÏÏÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ."
+"ÎÎÎÏÎÎÏÎÎÎÏÏÎ <gui>ÏÏÎÎÎÏÎ ÎÎÏÏÎÏÎÎÏÎ ÏÎÎÎÏÏÎ</gui>. ÎÏÎÎ ÎÏÏÎÎÎÎ ÏÎÎÎÎÎ, "
+"ÎÏÎÎÎÎÏÎ <em>clutter-1.0</em> ÎÏÏ ÏÎ ÎÎÏÏÎ ÎÎÎ ÎÎ ÏÏÎÏÎÏÎÎÎÎÎÏÎ ÏÎ "
+"ÎÎÎÎÎÎÎÎÎÎ Clutter ÏÏÎ ÎÏÎÎ ÏÎÏ."
+
+#: C/photo-wall.c.page:64(p) C/image-viewer.c.page:50(p)
+#: C/guitar-tuner.c.page:55(p)
+#| 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:"
+msgid ""
+"Click <gui>Apply</gui> and the project will be created for you. Open "
+"<file>src/main.c</file> from the <gui>Project</gui> or <gui>File</gui> tabs. "
+"You should see some code which starts with the lines:"
+msgstr ""
+"ÎÎÏÎÏÏÎ <gui>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÏÎÏ. ÎÎÎÎÎÏÎ ÏÎ "
+"<file>src/main.c</file> ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ <gui>ÎÏÎÎ</gui> Î "
+"<gui>ÎÏÏÎÎÎ</gui>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÎÏÎÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ ÏÎÏ "
+"ÎÏÎÎÎÎÏ:"
 
+#: C/photo-wall.c.page:73(title)
+msgid "A look at Photo Wall"
+msgstr "ÎÎÎ ÎÎÏÎÎ ÏÏÎ ÏÏÏÎÎÏÎÏÎÎÏ ÏÎÎÎÎÎ"
+
+#: C/photo-wall.c.page:74(p)
+msgid "Our image viewer presents the user with a wall of images."
+msgstr "Î ÏÏÎÎÎÎÎÎÏ ÎÎÎÏÎÎÏ ÎÎÏ ÏÎÏÎÏÏÎÎÎÎÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎ ÏÎÎÏÎ ÎÎÎÏÎÏÎ."
+
+#: C/photo-wall.c.page:78(p)
 msgid ""
-"This code is ready to be used, so you can run it by clicking "
-"<guiseq><gui>Run</gui><gui>Execute</gui></guiseq>."
+"When an image is clicked, it is animated to fill the viewing area. When the "
+"image having focus is clicked it is returned to its original position using "
+"an animation with the same duration of 500 milliseconds."
 msgstr ""
-"Î ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ, ÎÏÏÏÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÎ ÎÎÏÎÎÎÏÎÏÎ "
-"ÏÎÎÎÎÎÎÎÏÎÏ <guiseq><gui>ÎÎÏÎÎÎÏÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq>."
+"ÎÏÎÎ ÎÎÎÎÏÎÎ ÎÎÎÎ ÏÎ ÎÎÎ ÎÎÎÏÎÎ, ÎÎÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÎÎÎÏÎÎ ÏÎÎ ÏÎÏÎÎÏÎ "
+"ÏÏÎÎÎÎÎÏ. ÎÏÎÎ ÎÎÎÎÏÎÎ ÎÎÎÎ ÏÎ ÎÎÎ ÎÏÏÎÎÏÎÎÎÎ ÎÎÎÏÎÎ ÎÏÎÏÏÏÎÏÎÏÎÎ ÏÏÎÎ "
+"ÎÏÏÎÎÎ ÏÎÏ ÎÎÏÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÎÎÎ ÎÎÎÎÏÎ ÎÎ ÏÎÎ ÎÎÎÎ ÎÎÎÏÎÎÎÎ ÏÏÎ 500 ms."
 
+#: C/photo-wall.c.page:84(title)
+msgid "Initial setup"
+msgstr "ÎÏÏÎÎÎ ÏÏÎÎÎÏÎ"
+
+#: C/photo-wall.c.page:85(p)
 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>."
+"The following code segment contains many of the defines and variables we "
+"will be using in the following sections. Use this as a reference for later "
+"sections. Copy this code to the beginning of <file>src/main.c</file>:"
 msgstr ""
-"ÎÎÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>ÎÎÎÎÏÎ</gui> (ÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>ÎÏÎÏÎÎÎ "
-"ÏÏÏÏÎÏÎÎÎ</gui>) ÎÎÎ ÎÏÎÎÏÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÎÏ ÎÎÏÎÏÎÎÏ. "
-"ÎÏÎÏÎÎÏÎ ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ ÏÎÏ ÎÎ "
-"ÎÎÎÎÎÏÎÎ ÏÏÎÎ ÏÎÏÎÎÎÎ ÏÎ ÎÎÏÎÏÎ. ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÏÎÏÎÏÏÎ ÏÎÎÏ ÏÏÎÎ "
-"ÏÏÎÎÎ <gui>ÎÎÎÏÎÏÏÎÏ</gui> ÏÎÏ ÏÎÎÎÏÎÏ ÎÎÎ ÎÏÎÏÏÎ <code>on_button_clicked</"
-"code> ÎÎÎ ÏÎÏÎÏÏÎ <key>Return</key>."
+"ÎÎ ÏÎÏÎÎÎÏÏ ÏÎÎÎÎ ÎÏÎÎÎÎ ÏÎÏÎÎÏÎÎ ÏÎÎÎÎÏÏ ÎÏÎÏÎÎÏÏ ÎÎÎ ÎÎÏÎÎÎÎÏÎÏ ÏÎÏ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÏÎÏ ÏÎÏÎÎÎÏÏ ÎÎÏÏÎÏÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÎÏÏÏ ÏÏ ÎÎÎÏÎÏÎ ÎÎÎ "
+"ÎÎÎÎÏ ÎÎÏÏÎÏÎÏ. ÎÎÏÎÎÏÎÏÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÏÎÎ ÎÏÏÎ ÏÎÏ "
+"<file>src/main.c</file>:"
 
-msgid "Write the signal handler"
-msgstr "ÎÏÎÏÏÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ"
+#: C/photo-wall.c.page:122(title)
+msgid "Jumping into the code"
+msgstr "ÎÎÏÎÎÎÏÎ ÏÏÎÎ ÎÏÎÎÎÎ"
 
+#: C/photo-wall.c.page:123(p)
 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."
+"We will start by taking a look at the <code>main()</code> function as a "
+"whole. Then we'll discuss the other code sections in detail. Change the "
+"<file>src/main.c</file> to contain this <code>main()</code> function. You "
+"can delete the <code>create_window()</code> function as we don't need it in "
+"this example."
 msgstr ""
-"ÎÏÎÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ, ÎÎÎÎÏÎ ÏÎÎ ÏÎ ÎÎÏÎÏÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎÎ ÎÎÎÎ "
-"ÏÏÎÎÏÏÎÏÎ, <gui>on_button_clicked</gui>, ÏÏÎÎ ÏÎÏÎÎÎÏÎ. ÎÏÎÏÎÎ ÎÎ "
-"ÏÏÎÏÎÎÏÎÏÎÎ ÎÏÏÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ ÏÏÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ."
+"ÎÎ ÎÎÎÎÎÎÏÎÏÎÎ ÏÎÏÎÎÎÏÎÏ ÎÎÎ ÎÎÏÎÎ ÏÏÎ ÏÏÎÎÏÏÎÏÎ <code>main()</code> ÏÏ "
+"ÏÏÎÎÎÎ. ÎÏÎÎÏÎ ÎÎ ÏÏÎÎÏÎÏÎÏÎÎ ÏÎÏ ÎÎÎÎÏ ÎÎÏÏÎÏÎÏ ÎÏÎÎÎÎ ÎÎÏÏÎÎÎÏÏÏ. ÎÎÎÎÎÏÎ "
+"ÏÎ <file>src/main.c</file> ÎÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÏÏÎÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ "
+"<code>main()</code>. ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎÏÎÏÎÏÎ ÏÎ ÏÏÎÎÏÏÎÏÎ "
+"<code>create_window()</code> ÎÎÎÏÏ ÎÎÎ ÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎ ÏÎ ÎÏÏÏ ÏÎ "
+"ÏÎÏÎÎÎÎÎÎÎ."
+
+#: C/photo-wall.c.page:164(p)
+msgid ""
+"Line 4: <code>ClutterColor</code> is defined by setting the red, green, blue "
+"and transparency (alpha) values. The values range from 0-255. For "
+"transparency a value of 255 is opaque."
+msgstr ""
+"ÎÏÎÎÎÎ 4: <code>ClutterColor</code> ÎÏÎÏÏÎÎÎ ÎÏÎÎÎÎÏÎÏ ÏÎÏ ÏÎÎÎÏ ÎÏÎÎÎÎÎÏ, "
+"ÏÏÎÏÎÎÎÏ, ÎÎÎÎÎÎÎÏ ÎÎÎ ÎÎÎÏÎÎÎÎÎÏ (ÎÎÏÎ). ÎÎ ÎÏÏÎÏ ÏÎÎÏÎ ÎÏÏ 0-255. ÎÎÎ "
+"ÎÎÎÏÎÎÎÎÎ ÏÎÎÎ 255 ÎÎÎÎÎ ÎÎÎÎÏÎÎÎÏ."
 
+#: C/photo-wall.c.page:165(p)
 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:"
+"Line 7: You must initialize Clutter. If you forget to do this, you will get "
+"very strange errors. Be warned."
 msgstr ""
-"ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÎÎÎÎÎÏÎ ÏÎ <file>guitar_tuner.py</file>, ÎÏÎÎÏÎÏ "
-"ÎÎÎÎÏÏÏ ÎÎÎ ÏÎ ÎÏÏÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ. ÎÎÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ "
-"<gui>ÎÎÎÎÏÎ</gui> ÏÎÏ ÎÎÏÎÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎ ÏÎÎÎ. ÎÏÏÎ "
-"ÏÎÏÏÎ ÏÎÎ ÏÎÎÏÎ ÏÏÎÏ ÎÎÏÎÏÎ ÎÎÎÎÎ ÏÎ ÏÎÎÎ <gui>clicked</gui> ÎÎÎ ÏÏÏÎÏÎ ÏÎÎ "
-"ÏÏÎÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ ÎÎÏÎ ÏÏÎÎ ÎÏÏÎÎ (main) ÎÎÎÏÎ. Î ÎÎÏÎÎÏÎÎÏ ÎÏÎÎÎÎÏ ÎÎ "
-"ÏÏÎÏÏÎÎÎÎ ÏÏÎÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ:"
+"ÎÏÎÎÎÎ 7: ÎÏÎÏÎÎ ÎÎ ÎÏÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎ Clutter. ÎÎÎ ÏÎ ÎÎÏÎÏÎÏÎ, ÎÎ ÏÎÏÎÏÎ "
+"ÏÎÎÏ ÏÎÏÎÎÏÎÎ ÏÏÎÎÎÎÏÎ. ÎÏÎÎÎÎÎÏÎÎÎÎÎÎÎÏÎ."
 
+#: C/photo-wall.c.page:166(p)
 msgid ""
-"This signal handler has two arguments: the usual Python class pointer, and "
-"the <code>Gtk.Button</code> that called the function."
+"Lines 9â11: Here we get the default <code>ClutterStage</code> that was "
+"provided by <code>clutter_init</code>. We then set the size using the "
+"defines from the previous section and the address of the <code>ClutterColor</"
+"code> we just defined."
 msgstr ""
-"Î ÏÎÎÏÎÏÏÎÏ ÏÎÎÎÏÏÎ ÎÏÎÎ ÎÏÎ ÏÎÏÎÎÎÏÏÎÏÏ: ÏÎÎ ÏÏÏÎÎÏ ÎÎÎÎÏÎ (pointer) ÎÎÎÏÎÏ "
-"ÏÎÏ Python ÎÎÎ ÏÎ <code>Gtk.Button</code> ÏÎÏ ÎÎÎÎÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ."
+"ÎÏÎÎÎÎÏ 9-11. ÎÎÏ ÏÎÎÏÎÎÏÎÎ ÏÎÎ ÏÏÎÎÏÎÎÎÎÎ <code>ClutterStage</code> ÏÎÏ "
+"ÎÏÎÎÎÎ ÎÏÏ <code>clutter_init</code>. ÎÏÎÎÏÎ ÎÏÎÎÎÏÎÎ ÏÎ ÎÎÎÎÎÎÏ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÏÏ ÎÏÎÏÎÎÏÏ ÎÏÏ ÏÎÎ ÏÏÎÎÎÎÏÎÎÎÎ ÎÎÏÏÎÏÎ ÎÎÎ ÏÎ ÎÎÎÏÎÏÎÏÎ "
+"ÏÎÏ <code>ClutterColor</code> ÏÎÏ ÎÏÎÎÏ ÎÏÎÏÎÎÎ."
 
+#: C/photo-wall.c.page:167(p)
 msgid ""
-"Change the import line in <file>guitar_tuner.py</file>, just at the "
-"beginning to :"
+"A <code>ClutterStage</code> is the top-level <code>ClutterActor</code> onto "
+"which other <code>ClutterActor</code>s are placed."
 msgstr ""
-"ÎÎÎÎÎÏÎ ÏÎ ÎÏÎÎÎÎ import ÏÏÎ ÎÏÏÎÎÎ <file>guitar_tuner.py</file>, ÎÏÎÎ ÏÏÎÎ "
-"ÎÏÏÎ ÏÎ :"
+"ÎÎÎÏ <code>ClutterStage</code> ÎÎÎÎÎ ÎÎÏÏÎÏÎÏ ÎÏÎÏÎÎÎÏ "
+"<code>ClutterActor</code> ÏÏÎÎ ÎÏÎÎÎ ÎÎÎÎÎ <code>ClutterActor</code> "
+"ÏÎÏÎÎÎÏÎÏÎÏÎÎ."
 
+#: C/photo-wall.c.page:169(p)
 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:"
+"Line 12: Here we call our function for getting the image file paths. We'll "
+"look at this in a bit."
 msgstr ""
-"ÎÎ <code>Gst</code> ÏÎÏÎÎÏÎÎ ÏÎ ÎÎÎÎÎÎÎÎÎÎ GStreamer. ÎÏÎÏÎÏ ÏÏÎÏÎÎ ÎÎ "
-"ÎÏÏÎÎÎÏÎÎÎÏÎÏÎ ÏÏÏÏÎ ÏÎ GStreamer ÏÎ ÎÏÎÎÎ ÎÎÎÎÏÎÎ ÏÏÎ ÎÎÎÎÎÎ <code>main()</"
-"code> ÎÎ ÏÎÎ ÏÏÎÏÎÎÎÎ ÎÏÏÎÏ ÎÏÎÎÎÎÏ ÏÎÎÏ ÎÏÏ ÏÎÎ ÎÏÎÎÎÎ <code>app = GUI()</"
-"code>:"
+"GÏÎÎÎÎ 12: ÎÎÏ ÎÎÎÎÏÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ ÎÎÏ ÎÎÎ ÎÎÏÎ ÏÏÎ ÎÎÎÎÏÎÎÏÎ ÎÏÏÎÎÎÏ "
+"ÎÎÎÏÎÎÏ. ÎÎ ÏÎ ÎÎÏÎÎ ÏÎ ÎÎÎÎ."
 
+#: C/photo-wall.c.page:170(p)
 msgid ""
-"Then, copy the following function into the main class in <file>guitar_tuner."
-"py</file> somewhere:"
+"Lines 14â26: This is where we set up the <code>ClutterActor</code>s, load "
+"the images and place them into their spot in the image wall. We will look at "
+"this in detail in the next section."
 msgstr ""
-"ÎÎÏÎ, ÎÎÏÎÎÏÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÏÏÎÎÏÏÎÏÎ ÎÎÏÎÏ ÏÏÎÎ ÎÏÏÎÎ (main) ÎÎÎÏÎ ÏÏÎ "
-"ÎÏÏÎÎÎ <file>guitar_tuner.py</file>:"
+"ÎÏÎÎÎÎÏ 14-26: ÎÎÏ ÏÏÎÎÎÎÎÏÎÎ ÏÎ <code>ClutterActor</code>s, ÏÏÏÏÏÏÎ ÏÏÎ "
+"ÎÎÎÏÎÏÎ ÎÎÎ ÏÎÏÎÎÎÏÎÏÎ ÏÎÏÏ ÏÏÎ ÏÎÎÎÎÎ ÏÎÏÏ ÏÏÎÎ ÏÎÎÏÎ ÎÎÎÏÎÎÏ. ÎÎ ÏÎ ÎÎÏÎÎ "
+"ÎÎÏÏÎÎÎÏÏÏ ÏÏÎÎ ÎÏÏÎÎÎÎ ÎÎÏÏÎÏÎ."
 
+#: C/photo-wall.c.page:171(p)
 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)."
+"Line 29: Show the stage and <em>all its children</em>, meaning our images."
 msgstr ""
-"ÎÎ ÏÏÎÎÏ ÏÏÏÏÎÏ ÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ ÏÎÎÎ (source), ÎÎÎÎÎ (sink) "
-"ÎÎÎ ÏÏÎÎÎÏÏÎ (pipeline) (ÏÎ ÎÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÎÎÏÎÎÏ ÎÎÎ ÏÎ ÎÏÎ "
-"ÎÎÎÎ ÏÏÎÎÏÎÎÎ). ÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎÎ Ânote ÏÏÎ ÏÏÎÎÎÏÏΠÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÏÎÎÎ "
-"Âsource ÎÎÎ ÏÎ ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎ <code>audiotestsrc</code> ÎÎÎ "
-"ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ Âoutput ÎÎÎ ÏÎÎ ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÎÎÎ "
-"<code>autoaudiosink</code> (ÏÏÎÎÏÎÎÎÎÎÎÎÎ ÎÎÏÏÎ ÎÏÎÏ)."
+"ÎÏÎÎÎÎ 29: ÎÎÏÎÎÎÏÎ ÏÎÏ ÏÏÎÎÎÎÏ ÎÎÎ <em>ÏÎÏÎ ÏÏÎ ÎÎÏÎÏÎÏÏÎ ÏÎÏ</em>, ÏÎÏ "
+"ÏÎÎÎÎÎÎÎ ÏÏÎ ÎÎÎÏÎÏÎ ÎÎÏ."
+
+#: C/photo-wall.c.page:172(p)
+msgid "Line 32: Start the Clutter main loop."
+msgstr "ÎÏÎÎÎÎ 32: ÎÎÎÏÎÎ ÏÎÏ ÎÏÏÎÎÏ ÎÏÏÏÎÏ ÏÎÏ Clutter."
 
+#: C/photo-wall.c.page:177(title)
+msgid "Setting up our image actors"
+msgstr "ÎÎÎÎÏÎÏÏÎÏÎ ÏÏÎ ÎÏÎÏÏÏÎ ÎÎÎÏÎÎÏ"
+
+#: C/photo-wall.c.page:178(p)
 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."
+"In Clutter, an actor is the most basic visual element. Basically, everything "
+"you see is an actor."
 msgstr ""
-"ÎÎ ÎÎÎÎÏÎÎ ÏÎÏ <code>source.set_property</code> ÎÏÎÎÎÎ ÏÎÎ ÎÎÎÏÏÎÏÎ "
-"<code>freq</code> ÏÎÏ ÏÏÎÎÏÎÎÎÏ ÏÎÎÎ ÏÎ <code>frequency</code>, Î ÎÏÎÎÎ ÎÏÎÎ "
-"ÏÎÏÎÏÏÎÎ ÏÎÎ ÏÎÏÎÎÎÏÏÎÏ ÏÏÎ ÏÏÎÎÏÏÎÏÎ <code>play_sound</code>. ÎÏÏÎ ÎÎÎÎÎ Î "
-"ÏÏÏÎÏÏÎÏÎ ÏÎÏ ÎÏÏÎÏ ÏÎ Hertz ÏÎÎÎÎÏ ÏÏÎÏÎÎÎÏ ÏÏÏÎÏÏÎÏÎÏ ÎÎ ÎÏÎÏÏÎÏÎ "
-"ÎÏÎÏÏÎÏÎ."
+"ÎÏÎ Clutter, ÎÎÎÏ ÎÏÎÏÏÎÏ ÎÎÎÎÎ ÏÎ ÏÎÎ ÎÎÏÎÎÏ ÎÏÏÎÎÏ ÏÏÎÎÏÎÎÎ. ÎÎÏÎÎÎ, "
+"ÎÏÎÎÎÏÎÏÎ ÎÎÎÏÎÏÎ ÎÎÎÎÎ ÎÎÎÏ ÎÏÎÏÏÎÏ."
 
+#: C/photo-wall.c.page:179(p)
 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."
+"In this section, we are going to take a closer look at the loop used for "
+"setting up the <code>ClutterActor</code>s that will display our images."
 msgstr ""
-"ÎÎ ÎÏÏÎÎÎÎÏ ÎÏÎ ÎÏÎÎÎÎÏ ÎÎÎÎÏÎ ÏÎ <code>pipeline.add</code>, ÎÎÎÎÎÏÎÏ ÏÎÎ "
-"ÏÎÎÎ ÎÎÎ ÏÎÎ ÎÎÎÎÎ ÏÏÎ ÏÏÎÎÎÏÏÎ. Î ÏÏÎÎÎÏÏÎ ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎÏÎÏÎ "
-"ÏÏÎÎÏÎÎÎ ÏÎÏ GStreamer. ÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ ÏÏÎÎÏÎÎÎ ÎÎÎÎÏÎ "
-"ÏÏÎ ÏÏÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ ÏÏÎÎÏÏÎÎÎÎ ÏÎ ÎÎÎÎÎÎ <code>add</code>."
+"ÎÎ ÎÏÏÎÎ ÏÎÎ ÎÎÏÏÎÏÎ, ÏÏÏÎÎÎÏÎÎ ÎÎ ÎÎÎÏÎÎÎÏÎÎ ÏÏÎÎÏÏÎÏÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎÎÎ "
+"ÎÏÏÏÎ ÎÎÎ ÎÎÎÎÏÎÏÏÎÏÎ ÏÎÏ <code>ClutterActor</code>s ÏÎÏ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎÏ "
+"ÎÎÎÏÎÎÏ ÎÎÏ."
 
+#: C/photo-wall.c.page:197(p)
 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>)."
+"Line 5: Here we want to get the path at the <var>n</var>th location in the "
+"<code>GSList</code> that is holding our image path names. The <var>n</var>th "
+"position is calculated based on <code>row</code> and <code>col</code>. The "
+"return value is a pointer to a <code>GSList</code> which is just a node in "
+"the list. We will use this to get the actual path in the next line. The "
+"first parameter is a pointer to the head of the list."
 msgstr ""
-"ÎÎÏÎ Î <code>pipeline.set_state</code> ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎÎ Î "
-"ÎÎÎÏÎÏÎÎÏÎÎ, ÎÎÎÎÎÎÎÏÎÏ ÏÎÎ ÎÎÏÎÏÏÎÏÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ ÏÎ ÎÎÎÏÎÏÎÎÏÎÎ "
-"(<code>Gst.State.PLAYING</code>)."
+"ÎÏÎÎÎÎ 5: ÎÎÏ ÎÎÎÎÏÎÎ ÎÎ ÏÎÏÎÏÎÎ ÏÎ ÎÎÎÎÏÎÎÎ ÏÏÎ ÎÎÏÎ <var>n</var>Î ÏÏÎ "
+"<code>GSList</code> ÏÎÏ ÎÏÎÏÎ ÏÎ ÎÎÏÎÎÏÎ ÎÎÎÎÏÎÎÎÏ ÎÎÎÏÎÎÏ. Î <var>n</var> "
+"ÎÎÏÎ ÏÏÎÎÎÎÎÎÎÏÎÎ ÎÎÏÎÏÎÎÎÎ ÏÏÎ <code>row</code> ÎÎÎ <code>col</code>. Î "
+"ÎÏÎÏÏÏÎÏÏÎÎÎÎ ÏÎÎÎ ÎÎÎÎÎ ÎÎÎÏ ÎÎÎÎÏÎÏ ÏÎ ÎÎÎ <code>GSList</code> ÏÎÏ ÎÎÎÎÎ "
+"ÎÏÎÎ ÎÎÎÏ ÎÏÎÎÎÏ ÏÏÎ ÎÎÏÏÎ. ÎÎ ÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÏÎ ÎÎÏÎ ÏÎÏ ÎÎÎÏÎÎÏ "
+"ÎÎÎÎÏÎÎÎÏ ÏÏÎÎ ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ. Î ÏÏÏÏÎ ÏÎÏÎÎÎÏÏÎÏ ÎÎÎÎÎ ÎÎÎÏ ÎÎÎÎÏÎÏ ÏÏÎÎ "
+"ÎÎÏÎÎÎ ÏÎÏ ÎÎÏÏÎÏ."
+
+#: C/photo-wall.c.page:199(p)
+msgid ""
+"Line 6: This is where we actually create the <code>ClutterActor</code> and "
+"place the image into the actor. The first argument is the path which we "
+"access through our <code>GSList</code> node. The second argument is for "
+"error reporting but we are ignoring that to keep things short."
+msgstr ""
+"ÎÏÎÎÎÎ 6: ÎÎÏ ÎÎÎÎÎÏÏÎÎÎÏÎÎ ÏÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎÏÎ Î <code>ClutterActor</code> "
+"ÎÎÎ ÏÎÏÎÎÎÏÎÎÏÎÎ Î ÎÎÎÏÎÎ ÏÏÎÎ ÎÏÎÏÏÎ. ÎÎ ÏÏÏÏÎ ÏÏÎÏÎÎ ÎÎÎÎÎ Î ÎÎÎÎÏÎÎÎ "
+"ÏÏÎÏÏÎÎÎÏÎÏ ÎÎÏÎ ÎÏÏ ÏÎÎ ÎÏÎÎÎ <code>GSList</code>. ÎÎ ÎÎÏÏÎÏÎ ÏÏÎÏÎÎ ÎÎÎÎÎ "
+"ÎÎÎ ÎÎÎÏÎÏÎ ÏÏÎÎÎÎÏÎÏ, ÎÎÎÎ ÏÎ ÎÎÎÎÎÏÎÎ ÎÎÎ ÎÏÎÎÏÏ ÏÏÎÏÎÎÎÎÏ."
 
-msgid "Stopping playback"
-msgstr "ÎÎÎÎÎÏÎ ÎÎÎÏÎÏÎÎÏÎÎÏ"
+#: C/photo-wall.c.page:201(p)
+msgid "Line 7: We'll look at this function in a later section."
+msgstr "ÎÏÎÎÎÎ 7: ÎÎ ÎÎÏÎÎ ÎÏÏÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ ÏÎ ÎÏÏÎÎÎÎ ÎÎÏÏÎÏÎ."
 
+#: C/photo-wall.c.page:203(p)
 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>."
+"Line 8: This adds the <code>ClutterActor</code> to the stage, which is a "
+"container. It also assumes ownership of the <code>ClutterActor</code> which "
+"is something you'll want to look into as you get deeper into GNOME "
+"development. See the <link href=\"http://library.gnome.org/devel/gobject/";
+"stable/gobject-memory.html\"><code>GObject</code> documentation</link> for "
+"the gory details."
 msgstr ""
-"ÎÎÎ ÎÎÎÎÏÎÎ ÎÎ ÏÎÎÎÎÏÎÎ ÎÎÎÎ ÎÎÎÏÎÎÏÎÎÏ ÎÏÎ ÎÎÎ ÏÎÎÏÎ, ÎÏÏÏÎ ÏÎ ÏÎÎÎÏÏÎÎÎ "
-"ÏÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎ Î <code>play_sound</code> ÎÎÎÎÎ ÎÎ ÎÎÎÎÎ ÏÎ <code>GObject."
-"timeout_add</code>. ÎÏÏÏ ÎÏÎÎÎÎ ÎÎÎ ÏÏÎÎÎÎÏ ÏÎÏÎÎÏÏÎÎ ÏÎÏ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÎÎ "
-"ÎÏÎÂ ÏÎÏÎÎÎÎÎÎ ÎÎÎ <code>LENGTH</code> ÏÎÎÎÎÏÏÎ ÏÎÏ ÎÎÏÏÎÏÎÎÎÏÏÎÏ ÏÏÎÎ "
-"ÎÎÎÎÏÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ <code>pipeline_stop</code>, ÎÎÎ ÎÎ ÏÏÎÎÏÎÏÎÎ ÎÎ ÏÎÎ "
-"ÎÎÎÎÎ ÎÎÏÏÎ Î <code>pipeline_stop</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ <code>False</code>."
-
+"ÎÏÎÎÎÎ 8: ÎÏÏÎ ÏÏÎÏÎÎÏÎÎ ÏÎÎ <code>ClutterActor</code> ÏÏÎ ÏÏÎÎÎÎ, ÏÎÏ ÎÎÎÎÎ "
+"ÎÎÎÏ ÏÎÏÎÎÎÏÎÏ. ÎÏÎÏÎÏ ÏÏÎÎÎÏÎÎ ÎÎÎÎÎÏÎÏÎÎ ÏÎÏ <code>ClutterActor</code> "
+"ÏÎÏ ÎÎÎÎÎ ÎÎÏÎ ÏÎÏ ÎÎ ÎÎÎÎÏÎÏÎ ÎÎ ÎÎÎÏÎÎÎÏÎ ÎÎÎÏÏ ÏÎÎÎÎÎÎÏÎ ÎÎÎÏÏÎÏÎ ÏÏÎÎ "
+"ÎÎÎÏÏÏÎÎ ÏÎÏ GNOME. ÎÎÎÏÎ ÏÎÎ <link "
+"href=\"http://library.gnome.org/devel/gobject/stable/gobject-";
+"memory.html\"><code>GObject</code>ÏÎÎÎÎÏÎÏÏÎ</link> ÎÎÎ ÏÎÏ ÏÏÎÎÏÎÏ "
+"ÎÎÏÏÎÎÎÏÎÎÎÏ."
+
+#: C/photo-wall.c.page:205(p)
 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:"
+"Line 9: This adds our <code>ClutterActor</code> to a <code>GSList</code> so "
+"that we can later iterate over the <code>ClutterActor</code>s."
 msgstr ""
-"ÎÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ <code>pipeline_stop</code>, Î ÎÏÎÎÎ ÎÎÎÎÎÏÎÎ "
-"ÎÏÏ ÏÎ <code>GObject.timeout_add</code>. ÎÏÎÏÎÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÎÎÎ "
-"<em>ÏÎÎÏ</em> ÎÏÏ ÏÎ ÏÏÎÎÏÏÎÏÎ <code>play_sound</code>:"
+"ÎÏÎÎÎÎ 9: ÎÏÏÏ ÏÏÎÏÎÎÏÎÎ ÏÎ <code>ClutterActor</code> ÏÎ ÎÎÎ "
+"<code>GSList</code>, ÎÏÏÎ ÏÏÏÎ ÎÏÎÏÏÎÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÎ ÎÏÎÎÎÎÎÎÎÏÎÎ ÏÎ "
+"<code>ClutterActor</code>."
 
+#: C/photo-wall.c.page:206(p)
 msgid ""
-"You need to define the <code>LENGTH</code> constant inside the class, so add "
-"this code at the beginning of the main class:"
+"Interesting to note is that we want to prepend the <code>ClutterActor</"
+"code>s rather than append so that we avoid traversing the list upon each "
+"insertion. You will often see <code>g_slist_prepend</code> followed by "
+"<code>g_slist_reverse</code> because it faster than inserting many objects "
+"at the end of the list."
 msgstr ""
-"ÎÏÎÏÎÎ ÎÎ ÎÏÎÏÎÏÎ ÏÎ ÏÏÎÎÎÏÎ <code>LENGTH</code> ÎÎÏÎ ÏÏÎÎ ÎÎÎÏÎ, ÎÏÏÏÎ "
-"ÏÏÎÏÎÎÏÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÏÎÎ ÎÏÏÎ ÏÎÏ ÎÏÏÎÎ (main) ÎÎÎÏÎÏ:"
+"ÎÎÎÎÎÏÏÏÎ ÏÏÎ ÎÎÎÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎ ÏÎ <code>ClutterActor</code> ÏÎÏÎ ÎÎ ÏÎ "
+"ÏÏÎÏÎÏÏÎÏÎÏÎÎ ÎÎÎ ÎÏÎÏÏÎÎ ÎÎÎÏÏÎÏÎÏ ÏÎÏ ÎÎÏÏÎÏ ÎÎ ÎÎÎÎ ÎÎÏÎÎÏÎÎ. ÎÎ ÎÎÎÏÎ "
+"ÏÏÏÎÎ ÏÎ <code>g_slist_prepend</code> ÎÎÎÎÎÏÎÎÏÎÎÎÎ ÎÏÏ "
+"<code>g_slist_reverse</code> ÎÏÎÎÎÎ ÎÎÎÎÎ ÏÎÎ ÎÏÎÎÎÏÎ ÏÎÏÎ Î ÎÎÏÎÎÏÎÎ ÏÎÎÎÏÎ "
+"ÎÎÏÎÎÎÎÎÎÎÏÎ ÏÏÎ ÏÎÎÎÏ ÏÎÏ ÎÎÏÏÎÏ."
 
+#: C/photo-wall.c.page:212(title)
+msgid "Loading the images"
+msgstr "ÎÏÏÏÏÏÎ ÏÏÎ ÎÎÎÏÎÏÎ"
+
+#: C/photo-wall.c.page:213(p)
 msgid ""
-"The call to <code>pipeline.set_state</code> pauses the playback of the "
-"pipeline."
+"Let's take a short break from Clutter to see how we can get the file names "
+"from our image directory."
 msgstr ""
-"ÎÏÎÎ ÎÎÎÎÎÏÎÎ Î <code>pipeline.set_state</code> Î ÎÎÎÏÎÏÎÎÏÎÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ "
-"ÏÏÎÎÎÏÎÎÎ."
+"ÎÏ ÎÎÎÎÏÎÎ ÎÎÎ ÏÏÎÏÎÎÎ ÎÎÎÎÎÏÎ ÎÏÏ ÏÎ Clutter ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÏÏ ÎÏÎÏÎÏÎÎ ÎÎ "
+"ÏÎÏÎÏÎÎ ÏÎ ÎÎÏÎÎÏÎ ÎÏÏÎÎÎÏ ÎÏÏ ÏÎÎ ÎÎÏÎÎÎÎÏ ÎÎÏ ÏÏÎ ÎÎÎÏÎÏÎ."
 
-msgid "Define the tones"
-msgstr "ÎÏÎÏÏÎ ÏÎÏÏ ÏÏÎÎÏÏ"
+#: C/photo-wall.c.page:240(p)
+msgid ""
+"Lines 5 and 12: This opens our directory or, if an error occured, returns "
+"after printing an error message."
+msgstr ""
+"ÎÏÎÎÎÎÏ 5 ÎÎÎ 12: ÎÏÏÏ ÎÎÎÎÎÎÎ ÏÎÎ ÎÎÏÎÎÎÎÏ ÎÎÏ Î, ÎÎÎ ÏÏÎÎÎÎ ÏÏÎÎÎÎ, "
+"ÎÏÎÏÏÏÎÏÎÎ ÎÎÏÎ ÏÎÎ ÎÎÏÏÏÏÏÎ ÎÎÎ ÎÎÎÏÎÎ ÏÏÎÎÎÎÏÎÏ."
 
+#: C/photo-wall.c.page:241(p)
 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:"
+"Lines 14â23: The first line gets another file name from the <code>GDir</"
+"code> we opened earlier. If there was an image file (which we check by "
+"looking at its extension, \".png\" or \".jpg\") in the directory we proceed "
+"to prepend the image directory path to the filename and prepend that to the "
+"list we set up earlier. Lastly we attempt to get the next path name and "
+"reenter the loop if another file was found."
 msgstr ""
-"ÎÎÎÎÏÎÎ ÎÎ ÏÎÎÎÎÏÎÎ ÏÎ ÏÏÏÏÏ ÎÏÎ ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÎÎ ÎÎÎ ÎÎÏÎÏÎ. ÎÏÏÏÎ ÎÏÏ "
-"ÏÎÎ, ÎÎÎÎÏÎÎ ÎÎ ÎÎÏÎÏÎÎ ÏÎÏ ÏÏÏÎÏÏÎÏÎÏ ÎÎÎ ÏÎÏ ÎÎÎ ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ, ÎÎ "
-"ÎÏÎÎÎÏ ÎÎÎÎÎ ÎÏÎÏÎÎÎÎÏ (ÏÏÎÎ ÎÏÏÎ ÏÎÏ ÎÏÏÎÎÏ-main ÎÎÎÏÎÏ) ÎÎÏÎ ÏÎ ÎÎÎ ÎÎÎÎÎÏ "
-"(<em>dict</em> ÏÎÏ Python) ÏÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÏÎÎÎÎ ÎÎ ÏÎÏ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ "
-"ÎÎÏÎÎÏÎ ÏÏÎ ÏÎÏÎÏÎ:"
+"ÎÏÎÎÎÎÏ 14-23: Î ÏÏÏÏÎ ÎÏÎÎÎÎ ÏÎÎÏÎÎÎ ÎÎÎ ÎÎÎÎ ÏÎÎÎÎ ÎÏÏÎÎÎÏ ÎÏÏ ÏÎ "
+"<code>GDir</code> ÏÎÏ ÎÎÎÎÎÎÎÎ ÏÎÎ ÎÏÏÎÏ. ÎÎÎ ÏÏÎÏÏÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ (ÏÎÏ "
+"ÎÎÎÎÏÎÏÎÎ ÎÎÎÏÏÎÏÎÏ ÏÎÎ ÎÏÎÎÏÎÏÎ ÏÎÏ, \".png\" Î \".jpg\") ÏÏÎÎ ÎÎÏÎÎÎÎÎ "
+"ÏÏÎÎÏÎÎÎÏÎÎ ÎÎ ÏÏÎÏÎÏÏÎÏÎÎ ÏÎ ÎÎÎÎÏÎÎÎ ÎÎÏÎÎÏÎÎÏ ÎÎÎÏÎÎÏ ÏÏÎ ÏÎÎÎÎ ÎÏÏÎÎÎÏ "
+"ÎÎÎ ÏÎ ÏÏÎÏÎÏÏÎÏÎÎ ÏÏÎ ÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÏÏÎÏÎÎÎ ÎÏÏÎÏÎÏÎ. ÎÎÎÎÏÏÎÎÎ "
+"ÏÏÎÏÏÎÎÎÏÎÎ ÎÎ ÏÎÏÎÏÎÎ ÏÎ ÎÏÏÎÎÎÎ ÏÎÎÎÎ ÎÎÎÎÏÎÎÎÏ ÎÎÎ ÎÎÎÎÎÎÏÎÎÎÏÎÎ ÏÎ ÎÏÏÏÎ "
+"ÎÎÎ ÎÏÎÎÎÎ ÎÎÏÎÎÎ ÎÎÎÎ ÎÏÏÎÎÎ."
+
+#: C/photo-wall.c.page:246(title)
+#| msgid "Set up the pipeline"
+msgid "Set up the actors"
+msgstr "ÎÎÎÎÏÎÏÏÎÏÎ ÏÏÎ ÎÏÎÏÏÏÎ"
+
+#: C/photo-wall.c.page:247(p)
+msgid ""
+"We now take a look at the sizing and positioning of <code>ClutterActor</"
+"code>s and also readying the <code>ClutterActor</code> for user interaction."
+msgstr ""
+"ÎÏ ÏÎÎÎÏÎÎ ÎÎÎ ÎÎÏÎÎ ÏÏÏÎ ÏÏÎ ÎÎÎÎÎÎÏ ÎÎÎ ÏÎÎ ÏÎÏÎÎÎÏÎÏÎ ÏÎÏ "
+"<code>ClutterActor</code> ÎÎÎ ÎÏÎÏÎÏ ÎÎ ÎÏÎÎÎÎÏÎÏÎÎ ÏÎ "
+"<code>ClutterActor</code> ÎÎÎ ÎÎÎÎÎÎÏÎÎÏÎÏÎ ÏÏÎÏÏÎ."
 
+#: C/photo-wall.c.page:266(p)
 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:"
+"Line 7: Setting an actor reactive means that it reacts to events, such as "
+"<code>button-press-event</code> in our case. For Photo Wall, all "
+"<code>ClutterActor</code>s in the wall should initially be reactive."
 msgstr ""
-"ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ ÏÎÏ ÎÏÎÏÎÎÎ ÏÏÎÎ, <code>on_button_clicked</"
-"code>. ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ ÎÎÏÎÎÎ ÏÏÎÎÎÏÎÎ ÏÎÎ ÏÎ ÎÎÏÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎÏÎÎÏ "
-"ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ, ÎÎÎÎ ÎÏÏÏ ÎÎ ÎÎÎÎÎÏÏÎ ÏÎ ÏÎÎÎÎÏ ÎÏÎÎÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎ. "
-"ÎÎÏÎ ÎÏÏÎÏ, ÎÏÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎÏ ÎÏÎÎÎÏÎÏ ÏÏÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎ "
-"ÎÎÏÎÎ ÏÎÎÎ ÏÎÏÎÎÎÎÎ:"
+"ÎÏÎÎÎÎ 7: ÏÏÎÎÎÏÎ ÎÎÏÎÎÏÎÏÎÏ ÎÏÎÏÏÎ ÏÎÎÎÎÎÎÎ ÏÏÎ ÎÎÏÎÎÏÎ ÏÎ ÏÏÎÎÎÎÏÎ, ÏÎÏÎÎÎ "
+"ÏÏÏÏ <code>button-press-event</code> ÏÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÏ. ÎÎÎ ÏÏÏÎÎÏÎÏÎÎÏ "
+"ÏÎÎÏÎ, ÏÎÎÎ ÎÎ <code>ClutterActor</code> ÏÏÎÎ ÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎ ÎÏÏÎÎÎ ÎÎ "
+"ÎÎÎÎÎ ÎÎÏÎÎÏÎÏÏÎÎÎÎ."
 
+#: C/photo-wall.c.page:269(p)
 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 "
+"Line 9â12: Now we connect the <code>button-press-event</code> to the "
+"<code>actor_clicked_cb</code> callback which we will look at next."
+msgstr ""
+"ÎÏÎÎÎÎ 9-12: ÎÏÏÎ ÏÏÎÎÎÎÏÎÎ ÏÎ <code>button-press-event</code> ÏÏÎÎ "
+"ÎÏÎÎÎÎÎÎÏÎ <code>actor_clicked_cb</code> ÏÎÏ ÎÎ ÎÎÏÎÎ ÏÏÎ ÏÏÎÎÏÎÎÎ."
+
+#: C/photo-wall.c.page:272(p)
+msgid "At this point we've got a wall of images that are ready to be viewed."
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎÎ ÏÎÏÎÎÎ ÎÎÎÎ ÏÎÎÏÎ ÎÎÎÏÎÏÎ ÏÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ ÎÎ ÏÏÎÎÎÎÎÎÏÎ."
+
+#: C/photo-wall.c.page:276(title)
+msgid "Reacting to the clicks"
+msgstr "ÎÎÏÎÎÏÎÏÎ ÏÏÎ ÎÎÎÎ"
+
+#: C/photo-wall.c.page:321(p)
+msgid ""
+"Lines 1â4: We have to make sure our callback function matches the signature "
+"required for the <code>button_clicked_event</code> signal. For our example, "
+"we will only use the first argument, the <code>ClutterActor</code> that is "
+"actually clicked."
+msgstr ""
+"ÎÏÎÎÎÎÏ 1-4: ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÎÎÏÎÎ ÏÏÎ Î ÏÏÎÎÏÏÎÏÎ ÎÏÎÎÎÎÎÎÏÎÏ ÎÎÏ ÏÎÎÏÎÎÎÎÎ "
+"ÎÎ ÏÎÎ ÎÏÎÎÏÎÏÎÎÎÎ ÏÏÎÎÏÎÏÎ ÎÎÎ ÏÎ ÏÎÎÎ <code>button_clicked_event</code>. "
+"ÎÎÎ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÎÎÏ, ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÏÎÎ ÏÎ ÏÏÏÏÎ ÏÏÎÏÎÎ, ÏÎ "
+"<code>ClutterActor</code> ÏÎÏ ÏÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎÏÎ ÏÎÏÎÎÎÎÎ."
+
+#: C/photo-wall.c.page:323(p)
+msgid ""
+"A few words on the arguments we are not using in this example. The "
+"<code>ClutterEvent</code> is different depending on what event is being "
+"handled. For example, a key event produces a <code>ClutterKeyEvent</code> "
+"from which you can get the key being pressed among other information. For "
+"mouse click events you get a <code>ClutterButtonEvent</code> from which you "
+"can get the <code>x</code> and <code>y</code> values. See the Clutter "
+"documentation for other <code>ClutterEvent</code> types."
+msgstr ""
+"ÎÎÎÎÏ ÎÎÎÎÎÏ ÎÎÎ ÏÎ ÎÏÎÏÎÎÏÎ ÏÎÏ ÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ. Î "
+"<code>ClutterEvent</code> ÎÎÎÎÎ ÎÎÎÏÎÏÎÏÎÎÏÏ ÎÎÎÎÎÎÎ ÎÎ ÏÎ ÏÏÎÎÎÎ "
+"ÎÏÎÎÎÏÎÎÎÎÏÎÎ. ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, ÎÎÎ ÏÏÎÎÎÎ ÏÎÎÎÏÏÎÏ ÏÎÏÎÎÎÎ ÎÎÎ "
+"<code>ClutterKeyEvent</code> ÎÏÏ ÏÎ ÎÏÎÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÏÎÏÎ ÏÎ ÏÎÎÎÏÏÎ ÏÎÏ "
+"ÏÎÏÎÎÎÎÎ ÎÎÏÎÎÏ ÎÎÎÏÎ ÏÎÎÏÎÏÎÏÎÏÎ. ÎÎÎ ÏÎ ÏÏÎÎÎÎÏÎ ÎÎÎÎ ÏÎÏ ÏÎÎÏÎÎÎÎÏ "
+"ÏÎÎÏÎÎÏÎ <code>ClutterButtonEvent</code> ÎÏÏ ÏÎ ÎÏÎÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÏÎÏÎ ÏÎÏ "
+"ÏÎÎÎÏ <code>x</code> ÎÎÎ <code>y</code>. ÎÎÎÏÎ ÏÎÎ ÏÎÎÎÎÏÎÏÏÎ ÏÎÏ Clutter "
+"ÎÎÎ ÎÎÎÎÏÏ ÏÏÏÎÏÏ <code>ClutterEvent</code>."
+
+#: C/photo-wall.c.page:324(p)
+msgid ""
+"The <code>user_data</code> is what one uses to pass data into the the "
+"function. A pointer to any data type can be passed in. If you need multiple "
+"data to be passed into the callback, you can place the data into a struct "
+"and pass its address in."
+msgstr ""
+"Î <code>user_data</code> ÎÎÎÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÎÏÎÎÎÏ ÎÎÎ ÎÎ ÏÎÏÎÏÎÎ "
+"ÎÎÎÎÎÎÎÎ ÏÏÎ ÏÏÎÎÏÏÎÏÎ. ÎÎÎÏ ÎÎÎÎÏÎÏ ÏÎ ÎÏÎÎÎÎÎÏÎÏÎ ÏÏÏÎ ÎÎÎÎÎÎÎÏÎ ÎÏÎÏÎÎ ÎÎ "
+"ÏÎÏÎÏÏÎÎ. ÎÎÎ ÏÏÎÎÎÎÏÏÎÏÏÎ ÏÎÎÎÎÏÎÎ ÎÎÎÎÎÎÎÎ ÎÎ ÏÎÏÎÏÏÎÏÎ ÏÏÎÎ ÎÏÎÎÎÎÎÎÏÎ, "
+"ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎ ÏÎ ÎÎÎÎÎÎÎÎ ÏÎ ÎÎÎ ÎÎÎÎ ÎÎÎ ÎÎ ÏÎÏÎÏÎÏÎ ÏÎ "
+"ÎÎÎÏÎÏÎÏÎ ÏÎÏ."
+
+#: C/photo-wall.c.page:328(p)
+msgid ""
+"Line 7: We set up a static flag to track which state we are in: wall mode or "
+"focus mode. We start out in wall mode so no image has focus. Thus, we set "
+"the flag to <code>FALSE</code> initially."
+msgstr ""
+"ÎÏÎÎÎÎ 7: ÎÏÎÎÎÎÏÎÏÏÎÏÎÎ ÎÎÎ ÏÏÎÏÎÎÎ ÏÎÎÎÎÎ ÎÎÎ ÎÎÏÎÏÎÏÎÏ ÏÎÏ ÎÎÏÎÏÏÎÏÎÏ "
+"ÏÏÎÎ ÎÏÎÎÎ ÎÎÎÎÏÏÎ: ÎÎÏÎÏÏÎÏÎ ÏÎÎÏÎÏ Î ÎÎÏÎÏÏÎÏÎ ÎÏÏÎÎÏÎÏ. ÎÎÎÎÎÎÎÎ ÏÎ "
+"ÎÎÏÎÏÏÎÏÎ ÏÎÎÏÎÏ, ÎÏÏÎ ÎÎÎÎÎ ÎÎÎÏÎÎ ÎÎÎ ÎÏÎÎ ÎÏÏÎÎÏÎ. ÎÏÏÎ, ÎÏÎÎÎÏÎÎ ÏÎ "
+"ÏÎÎÎÎÎ ÏÎ <code>FALSE</code> ÎÏÏÎÎÎ."
+
+#: C/photo-wall.c.page:329(p)
+msgid ""
+"Line 9: This line of code runs a custom function, "
+"<code>foreach_set_focus_state</code>, for each element in our "
+"<code>actor_list</code>, passing it the address to the <code>is_focused</"
+"code> flag. We'll see the definition of the <code>foreach_set_focus_state</"
+"code> function in the next section."
+msgstr ""
+"ÎÏÎÎÎÎ 9: ÎÏÏÎ Î ÎÏÎÎÎÎ ÎÏÎÎÎÎ ÏÏÎÏÎÎ ÎÎÎ ÏÏÎÏÎÏÎÎÏÎÎÎÎ ÏÏÎÎÏÏÎÏÎ, "
+"<code>foreach_set_focus_state</code>, ÎÎÎ ÎÎÎÎ ÏÏÎÎÏÎÎÎ ÏÏÎ "
+"<code>actor_list</code> ÎÎÏ, ÏÎÏÎÏÎÏÎÏ ÏÎ ÎÎÎÏÎÏÎÏÎ ÏÏÎ ÏÎÎÎÎÎ "
+"<code>is_focused</code>. ÎÎ ÎÎÏÎÎ ÏÎÎ ÎÏÎÏÎÏ ÏÎÏ ÏÏÎÎÏÏÎÏÎÏ "
+"<code>foreach_set_focus_state</code> ÏÏÎÎ ÎÏÏÎÎÎÎ ÎÎÏÏÎÏÎ."
+
+#: C/photo-wall.c.page:330(p)
+msgid ""
+"Lines 13â19: Reaching this code means that one image currently has focus and "
+"we want to return to wall mode. The <code>clutter_actor_animate</code> "
+"function is used to animate a <code>ClutterActor</code>'s property or "
+"properties from the current state(s) to the specified state(s). The "
+"arguments are as follows:"
+msgstr ""
+"ÎÏÎÎÎÎÏ 13-19: ÎÏÎÎÎÎÏÎÏ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÎÎÎÎÎÎ ÏÏÎ ÎÎÎ ÎÎÎÏÎÎ ÏÎÏ ÎÏÎÎ "
+"ÏÏÎÏÎÏÏÎ ÎÏÏÎÎÏÎ ÎÎÎ ÎÎÎÎÏÎÎ ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÎ ÎÎÏÎÏÏÎÏÎ ÏÎÎÏÎÏ. Î ÏÏÎÎÏÏÎÏÎ "
+"<code>clutter_actor_animate</code> ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎ ÎÎÎÎÏÎ ÎÎÎÏ "
+"ÎÎÎÏÏÎÏÎÏ ÏÎÏ <code>ClutterActor</code> Î ÎÎÎÎÏÎÏÏÎ ÎÏÏ ÏÎÎ ÏÏÎÏÎÏÏÎÏ "
+"ÎÎÏÎÏÏÎÏÎÎÏ ÏÏÎÏ ÏÏÎÎÎÎÏÎÎÎÎÎÏ ÎÎÏÎÏÏÎÏÎÎÏ. ÎÎ ÎÏÎÏÎÎÏÎ ÎÎÎÎÎ ÏÏÏÏ "
+"ÎÎÎÎÎÏÎÎÎ:"
+
+#: C/photo-wall.c.page:332(p)
+msgid "The address of the <code>ClutterActor</code> to animate"
+msgstr "Î ÎÎÎÏÎÏÎÏÎ ÏÎÏ <code>ClutterActor</code> ÎÎÎ ÎÎÎÎÏÎ"
+
+#: C/photo-wall.c.page:333(p)
+msgid ""
+"The animation mode to use. Here we use <code>CLUTTER_LINEAR</code> so that "
+"we have a constant speed for animation."
+msgstr ""
+"Î ÎÎÏÎÏÏÎÏÎ ÎÎÎÎÏÎÏ ÎÎÎ ÏÏÎÏÎ. ÎÎÏ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ "
+"<code>CLUTTER_LINEAR</code> ÎÏÏÎ ÏÏÏÎ ÎÎ ÎÏÎÏÎÎ ÎÎÎ ÏÏÎÎÎÏÎ ÏÎÏÏÏÎÏÎ ÎÎÎ "
+"ÎÎÎÎÏÎ."
+
+#: C/photo-wall.c.page:334(p)
+msgid ""
+"The duration of the animation in milliseconds. I've chosen 500 ms for this "
+"example."
+msgstr "Î ÎÎÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÏÎÏ ÏÎ ms. ÎÏÎÎÎÎÎ 500 ms ÎÎÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ."
+
+#: C/photo-wall.c.page:335(p)
+msgid ""
+"The remaining arguments are property/value pairs. Here we want to set the "
+"<code>x</code> value to the starting <code>x</code> value this "
+"<code>ClutterActor</code> was at before being brought into focus."
+msgstr ""
+"ÎÎ ÏÏÎÎÎÎÏÏÎÎÎÎ ÎÏÎÏÎÎÏÎ ÎÎÎÎÎ ÎÎÏÎÎ ÎÎÎÏÏÎÏÎÏ/ÏÎÎÎÏ. ÎÎÏ ÎÎÎÎÏÎÎ ÎÎ "
+"ÎÏÎÏÎÏÎÎ ÏÎÎ ÏÎÎÎ <code>x</code> ÏÏÎÎ ÎÏÏÎÎÎ ÏÎÎÎ <code>x</code>, ÎÏÏÏÏ Î "
+"<code>ClutterActor</code> ÎÏÎÎ ÏÏÎÎ ÎÎÏÎÏÎÏÎÎÎ ÏÎ ÎÏÏÎÎÏÎ."
+
+#: C/photo-wall.c.page:336(p)
+msgid ""
+"The last argument must always be <code>NULL</code> to indicate that there "
+"are no more properties to be set."
+msgstr ""
+"ÎÎ ÏÎÎÎÏÏÎÎÎ ÏÏÎÏÎÎ ÏÏÎÏÎÎ ÏÎÎÏÎÏÎ ÎÎ ÎÎÎÎÎ <code>NULL</code> ÎÎÎ ÎÎ ÎÎÎÎÎÎ "
+"ÏÏÎ ÎÎÎ ÏÏÎÏÏÎÏÎ ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÎÎÏÏÎÏÎÏ ÎÎ ÎÏÎÏÏÎÏÎ."
+
+#: C/photo-wall.c.page:338(p)
+msgid ""
+"The <code>depth</code> property needs a little more explaining. We need to "
+"raise the focused image so that it doesn't slide behind other "
+"<code>ClutterActor</code>s. In this section we are returning it to the same "
+"depth as the others on the wall."
+msgstr ""
+"Î ÎÎÎÏÏÎÏÎ <code>depth</code> ÏÏÎÎÎÎÎÏÎÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎÎÎÏÎ. ÎÏÎÎÎÎÏÎÎÏÏÎ "
+"ÎÎ ÎÎÏÏÏÏÎÏÎÎ ÏÎÎ ÎÏÏÎÎÏÎÎÎÎ ÎÎÎÏÎÎ, ÎÏÏÎ ÏÏÏÎ ÎÎ ÎÎÎ ÎÎÎÏÎÎÏÎÎ ÏÎÏÏ ÎÏÏ "
+"ÎÎÎÎ <code>ClutterActor</code>. ÎÎ ÎÏÏÎ ÏÎÎ ÎÎÏÏÎÏÎ ÎÏÎÏÏÏÎÏÎÏÎÎ ÏÏÎ ÎÎÎÎ "
+"ÎÎÎÎÏ ÏÏÏÏ ÎÎ ÎÎÎÎÏ ÏÏÎÎ ÏÎÎÏÎ."
+
+#: C/photo-wall.c.page:339(p)
+msgid ""
+"Depth also determines which <code>ClutterActor</code>s receive events. A "
+"<code>ClutterActor</code> with a higher depth value receives the click "
+"events and can choose whether the event gets sent to <code>ClutterActor</"
+"code>s under it. We'll see how that works in a few steps."
+msgstr ""
+"ÎÎ ÎÎÎÎÏ ÎÏÎÏÎÏ ÎÎÎÎÏÎÎÎÎ ÏÎÎÎÏ <code>ClutterActor</code> ÎÎÏÎÏÎÎ ÏÏÎÎÎÎÏÎ. "
+"ÎÎÎÏ <code>ClutterActor</code> ÎÎ ÏÏÎÎÏÏÎÏÎ ÏÎÎÎ ÎÎÎÎÏÏ ÎÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎÎÏÎ "
+"ÎÎÎÎ ÎÎÎ ÎÏÎÏÎÎ ÎÎ ÎÏÎÎÎÎÎÎ ÎÎÎ ÏÎ ÏÏÎÎÎÎ ÏÏÎÎÎÎÏÎÎ ÏÏÎ "
+"<code>ClutterActor</code> ÎÎÏÏ ÎÏÏ ÎÏÏÏ. ÎÎ ÎÎÏÎÎ ÏÏÏ ÎÎÏÎÎÏÎÎ ÎÏÏÏ ÏÎ ÎÎÎÎ "
+"ÎÎÎÎÏÎ."
+
+#: C/photo-wall.c.page:341(p)
+msgid ""
+"Line 24: Reaching this line of code means we are currently in the wall state "
+"and are about to give a <code>ClutterActor</code> focus. Here we save the "
+"starting position so that we can return to it later."
+msgstr ""
+"ÎÏÎÎÎÎ 24: ÏÏÎÎÎÎÏÎÏ ÎÏÏÎ ÏÎ ÎÏÎÎÎÎ ÏÎÏ ÎÏÎÎÎÎ ÏÎÎÎÎÎÎÎ ÏÏÎ ÎÎÎÎÏÏÎ ÏÏÎÏ ÏÎ "
+"ÏÎÏÏÎ ÏÏÎÎ ÎÎÏÎÏÏÎÏÎ ÏÎÎÏÎÏ ÎÎÎ ÏÏÏÎÎÎÏÎÎ ÎÎ ÎÏÏÎÏÎÎ ÎÎÎ "
+"<code>ClutterActor</code> ÎÏÏÎÎÏÎ. ÎÎÏ ÎÏÎÎÎÎÎÏÎÏÎÎ ÏÎÎ ÎÏÏÎÎÎ ÎÎÏÎ, ÎÏÏÎ "
+"ÏÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÎ ÎÏÎÏÏÏÎÏÎÏÎÎ ÎÏÎÏÏÎÏÎ."
+
+#: C/photo-wall.c.page:342(p)
+msgid ""
+"Line 25: Setting the <code>ClutterActor</code>'s <code>reactive</code> "
+"property to <code>TRUE</code> makes this <code>ClutterActor</code> react to "
+"events. In this focused state the only <code>ClutterActor</code> that we "
+"want to receive events will be the <code>ClutterActor</code> being viewed. "
+"Clicking on the <code>ClutterActor</code> will return it to its starting "
+"position."
+msgstr ""
+"ÎÏÎÎÎÎ 25: ÎÏÎÎÎÎÏÎÏ ÏÎÎ ÎÎÎÏÏÎÏÎ <code>reactive</code> ÏÎÏ "
+"<code>ClutterActor</code> ÏÎ <code>TRUE</code> ÎÎÎÎÎ ÏÎ "
+"<code>ClutterActor</code> ÎÎ ÎÎÏÎÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎÎÏÎ. ÎÎ ÎÏÏÎ ÏÎÎ ÎÏÏÎÎÏÎÎÎÎ "
+"ÎÎÏÎÏÏÎÏÎ Î ÎÏÎÎÏ <code>ClutterActor</code> ÏÎÏ ÎÎÎÎÏÎÎ ÎÎ ÎÎÏÎÎÎ ÏÏÎÎÎÎÏÎ "
+"ÎÎ ÎÎÎÎÎ Î ÏÏÎÎÎÎÎÏÎÎÎÎÏ <code>ClutterActor</code>. ÎÎÎÎ ÏÏÎ "
+"<code>ClutterActor</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÏÎÎ ÎÏÏÎÎÎ ÏÎÏ ÎÎÏÎ."
+
+#: C/photo-wall.c.page:343(p)
+msgid ""
+"Lines 27â33: This is similar to the above block of code. Notice that we are "
+"setting the the depth to raise it above the other images."
+msgstr ""
+"ÎÏÎÎÎÎÏ 27-33: ÎÏÏÏ ÎÎÎÎÎ ÏÎÎÎÎ ÎÎ ÏÎÎ ÏÎÏÎÏÎÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎ. ÎÎÎÎÎÏÏÏÎ ÏÏÎ "
+"ÎÏÎÎÎÏÎÎ ÏÎ ÎÎÎÎÏ ÎÎÏÏÏÏÎÏ ÏÎÏ ÏÎÎÏ ÎÏÏ ÏÎÏ ÎÎÎÎÏ ÎÎÎÏÎÎÏ."
+
+#: C/photo-wall.c.page:344(p)
+msgid ""
+"Line 37: Here we toggle the <code>is_focused</code> flag to the current "
+"state."
+msgstr ""
+"ÎÏÎÎÎÎ 37: ÎÎÏ ÎÎÎÎÎÎÏÏÎÏÎÎ ÏÎ ÏÎÎÎÎÎ <code>is_focused</code> ÏÏÎÎ ÏÏÎÏÎÏÏÎ "
+"ÎÎÏÎÏÏÎÏÎ."
+
+#: C/photo-wall.c.page:345(p)
+msgid ""
+"As mentioned previously, the <code>ClutterActor</code>s with higher "
+"<code>depth</code> values receive events but can allow <code>ClutterActor</"
+"code>s below them to also receive events. Returning <code>TRUE</code> will "
+"stop events from being passed down, while <code>FALSE</code> will pass "
+"events down."
+msgstr ""
+"ÎÏÏÏ ÎÎÎÏÎÏÎÎÎÎ ÏÏÎÎÎÎÏÎÎÎÏÏ, Î <code>ClutterActor</code> ÎÎ ÏÏÎÎÏÏÎÏÎÏ "
+"ÏÎÎÎÏ <code>depth</code> ÎÎÏÎÏÎÎ ÏÏÎÎÎÎÏÎ ÎÎÎÎ ÎÏÎÏÎÏÎ ÎÎ ÎÏÎÏÏÎÏÎÏÎ "
+"<code>ClutterActor</code> ÎÏÏ ÎÎÏÏ ÏÎÏÏ ÎÎ ÎÎÏÎÎÏÎ ÎÏÎÏÎÏ ÏÏÎÎÎÎÏÎ. "
+"ÎÏÎÏÏÏÎÏÎ ÏÎ <code>TRUE</code> ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎÎÏÎ ÎÏÏ ÏÎ ÎÎ "
+"ÏÏÎÎÏÎÏÎÏÎ, ÎÎÏ <code>FALSE</code> ÎÎ ÏÏÎÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎÎÏÎ."
+
+#: C/photo-wall.c.page:347(p)
+msgid ""
+"Remember, however, that to receive events the <code>ClutterActor</code>s "
+"must be set <code>reactive</code>."
+msgstr ""
+"ÎÎ ÎÏÎÏÏÎÏÏÎ, ÏÎÏÏ, ÏÏÎ ÎÎÎ ÎÏÎÎÎÏÎ ÏÏÎÎÎÎÏÏÎ ÏÎ <code>ClutterActor</code> "
+"ÏÏÎÏÎÎ ÎÎ ÎÏÎÏÏÎÎ ÏÎ <code>reactive</code>."
+
+#: C/photo-wall.c.page:351(p)
+msgid ""
+"The following is the convenience function passed to <code>g_slist_foreach</"
+"code>."
+msgstr ""
+"ÎÎ ÏÎÏÎÎÎÏÏ ÎÎÎÎÎ ÎÎÎ ÏÏÎÎÏÏÎÏÎ ÎÎÎÏÎÏÎÏÎÏÎÏ ÏÎÏ ÏÎÏÎÏÎ ÏÎ "
+"<code>g_slist_foreach</code>."
+
+#: C/photo-wall.c.page:364(p)
+msgid ""
+"Lines 2â5: The signature of this function requires two <code>gpointer</"
+"code>s. The first is a pointer to the <code>ClutterActor</code> that our "
+"<code>GSList</code> holds and the other is the <code>is_focused</code> flag "
+"that we've passed in the previous section. We want to cast these and store "
+"them for easy use."
+msgstr ""
+"ÎÏÎÎÎÎÏ 2-5: Î ÏÏÎÎÏÎÏÎ ÎÏÏÎÏ ÏÎÏ ÏÏÎÎÏÏÎÏÎÏ ÎÏÎÎÏÎÎ ÎÏÎ "
+"<code>gpointer</code>. ÎÎ ÏÏÏÏÎ ÎÎÎÎÎ ÎÎÎÏ ÎÎÎÎÏÎÏ ÏÏÎ "
+"<code>ClutterActor</code> ÏÎÏ Î <code>GSList</code> ÎÎÏ ÎÏÎÏÎ ÎÎÎ Î ÎÎÎÎÏ "
+"ÎÎÎÎÎ Î ÏÎÎÎÎÎ <code>is_focused</code> ÏÎÏ ÏÎÏÎÏÎÎÎ ÏÏÎÎ ÏÏÎÎÎÎÏÎÎÎÎ "
+"ÎÎÏÏÎÏÎ. ÎÎÎÎÏÎÎ ÎÎ ÏÎ ÎÎÎÎÎÎÏÎÎ ÎÎÎ ÎÎ ÏÎ ÎÏÎÎÎÎÎÏÏÎÏÎÎ ÎÎÎ ÎÏÎÎÎÎ ÏÏÎÏÎ."
+
+#: C/photo-wall.c.page:365(p)
+msgid ""
+"Line 7: Depending on which boolean value is passed in, the "
+"<code>ClutterActor</code> will be set to respond to events or not."
+msgstr ""
+"ÎÏÎÎÎÎ 7: ÎÎÎÎÎÎÎ ÎÎ ÏÎÎÎ ÏÎÎÎ ÎÏÎÏÎ ÏÎÏÎÏÎ, Î <code>ClutterActor</code> ÎÎ "
+"ÎÏÎÏÏÎÎ ÎÎ ÎÏÎÎÏÎÏÎÎ Î ÏÏÎ ÏÏÎ ÏÏÎÎÎÎÏÎ."
+
+#: C/photo-wall.c.page:370(title) C/image-viewer.vala.page:273(title)
+#: C/image-viewer.cpp.page:204(title) C/image-viewer.c.page:215(title)
+#: C/guitar-tuner.vala.page:247(title) C/guitar-tuner.cpp.page:249(title)
+#: C/guitar-tuner.c.page:250(title)
+#| msgid "Run the application"
+msgid "Build and run the application"
+msgstr "ÎÎÏÎÏÎÎÏÎ ÎÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÏÎÎÎÎÏ"
+
+#: C/photo-wall.c.page:371(p)
+msgid ""
+"All of the code should now be ready to go. All you need now is some pictures "
+"to load. By default, the pictures are loaded from a <file>berlin_images</"
+"file> directory. If you want, you can change the <code>#define "
+"IMAGE_DIR_PATH</code> line near the top to refer to your photo directory, or "
+"create a <file>berlin_images</file> directory by clicking "
+"<guiseq><gui>Project</gui><gui>New Directory...</gui></guiseq> and creating "
+"a <file>berlin_images</file> directory as a subdirectory of the <file>photo-"
+"wall</file> directory. Make sure to put at least twelve images in the "
+"directory!"
+msgstr ""
+"ÎÎÎÏ Î ÎÏÎÎÎÎÏ ÏÏÎÏÎÎ ÏÏÏÎ ÎÎ ÎÎÎÎÎ ÎÏÎÎÎÎÏ. ÎÏÏÎ ÏÏÎÎÎÎÏÏÎÏÏÎ ÎÎÏÎÎÎÏ "
+"ÎÎÎÏÎÎÏ ÎÎÎ ÏÏÏÏÏÏÎ. ÎÏÏ ÏÏÎÎÏÎÎÎÎÎ, ÎÎ ÎÎÎÏÎÎÏ ÏÎÏÏÏÎÎÎÏÎÎ ÎÏÏ ÎÎÎÎ "
+"ÎÎÏÎÎÎÎÎ <file>berlin_images</file>. ÎÎÎ ÎÎÎÎÏÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎ "
+"ÎÏÎÎÎÎ <code>#define IMAGE_DIR_PATH</code> ÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÏÎ ÎÎÎ ÎÎ "
+"ÎÎÎÏÎÏÎÎÎÏÎ ÏÏÎÎ ÎÎÏÎÎÎÎÎ ÏÏÏÎÎÏÎÏÎÏÎ, Î ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎ "
+"<file>berlin_images</file> ÎÎ ÎÎÎÎ ÏÏÎ <guiseq><gui>ÎÏÎÎ</gui><gui>ÎÎÎÏ "
+"ÎÎÏÎÎÎÎÎÏ...</gui></guiseq> ÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÏÏ ÎÎÏÎÎÏÎÎÏ "
+"<file>berlin_images</file> ÏÏ ÏÏÎÎÎÏÎÎÏÎÎÏ ÏÎÏ ÎÎÏÎÎÏÎÎÏ <file>photo-"
+"wall</file>. ÎÎÎÎÎÏÎÎÎÏÎ ÏÏÎ ÎÎÎÎÏÎ ÏÎÏÎÎÏÎÏÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÎÎÏ ÏÏÎÎ "
+"ÎÎÏÎÎÎÎÎ!"
+
+#: C/photo-wall.c.page:373(p)
+#| 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!"
+msgid ""
+"When you have done that, click <guiseq><gui>Build</gui><gui>Build Project</"
+"gui></guiseq> to build everything again, then <guiseq><gui>Run</"
+"gui><gui>Execute</gui></guiseq> to start the application."
+msgstr ""
+"ÎÏÎÎ ÏÎÎÎÎÏÏÎÏÎ, ÎÎÎÎ <guiseq><gui>ÎÎÏÎÏÎÎÏÎ</gui><gui>ÎÎÏÎÏÎÎÏÎ "
+"ÎÏÎÎÏ</gui></guiseq> ÎÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎ ÎÏÎÎÎÏÎÏÎ ÎÎÎÎ, ÎÏÎÎÏÎ "
+"<guiseq><gui>ÏÏÎÎÎÎÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq> ÎÎÎ ÎÎÎÏÎÎ ÏÎÏ "
+"ÎÏÎÏÎÎÎÎÏ."
+
+#: C/photo-wall.c.page:374(p)
+msgid ""
+"If you haven't already done so, choose the <file>Debug/src/photo-wall</file> "
+"application in the dialog that appears. Finally, hit <gui>Run</gui> and "
+"enjoy!"
+msgstr ""
+"ÎÎÎ ÎÎÎ ÏÎ ÎÏÎÏÎ ÎÎÎ ÎÎÎÎÎ, ÎÏÎÎÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ <file>Debug/src/photo-"
+"wall</file> ÏÏÎÎ ÎÎÎÎÎÎÎ ÏÎÏ ÎÎÏÎÎÎÎÎÏÎÎ. ÎÎÎÎÎÎ ÏÎÏÎÏÏÎ <gui>ÎÎÏÎÎÎÏÎ</gui> "
+"ÎÎÎ ÎÏÎÎÎÏÏÏÎ ÏÎ!"
+
+#: C/photo-wall.c.page:379(p)
+#| msgid ""
+#| "If you run into problems with the tutorial, compare your code with this "
+#| "<link href=\"image-viewer/image-viewer.py\">reference code</link>."
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"photo-wall/photo-wall.c\">reference code</link>."
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ "
+"<link href=\"photo-wall/photo-wall.c\">ÎÏÎÎÎÎÏ ÎÎÎÏÎÏÎÏ</link>."
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/messagedialog.vala.page:20(None) C/messagedialog.py.page:20(None)
+#: C/messagedialog.js.page:20(None)
+#| msgid ""
+#| "@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+msgid ""
+"@@image: 'media/messagedialog.png'; md5=1956288274018e2386d9cba96a2101de"
+msgstr ""
+"@@image: 'media/messagedialog.png'Â md5=1956288274018e2386d9cba96a2101de"
+
+#: C/messagedialog.vala.page:16(desc) C/messagedialog.py.page:16(desc)
+msgid "A message window"
+msgstr "ÎÎÎ ÏÎÏÎÎÏÏÎ ÎÎÎÏÎÎÏÎÏ"
+
+#: C/messagedialog.vala.page:19(title) C/messagedialog.py.page:19(title)
+#: C/messagedialog.js.page:19(title)
+msgid "MessageDialog"
+msgstr "MessageDialog"
+
+#: C/messagedialog.vala.page:21(p)
+msgid "A modal message dialog which can cause the world to explode."
+msgstr ""
+"ÎÎÎÏ ÎÏÎÎÎÎÎÏÏÎÎÏÏ ÎÎÎÎÎÎÎÏ ÎÎÎÏÎÎÏÎÏ ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÏÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÏÎÎÎ "
+"ÏÎÏ ÎÏÏÎÎÏ."
+
+#: C/messagedialog.vala.page:29(link)
+msgid "Gtk.ResponseType"
+msgstr "Gtk.ResponseType"
+
+#: C/messagedialog.vala.page:30(link) C/messagedialog.js.page:32(link)
+msgid "Gtk.MessageDialog"
+msgstr "Gtk.MessageDialog"
+
+#: C/messagedialog.vala.page:31(link)
+msgid "Gtk.DialogFlags"
+msgstr "Gtk.DialogFlags"
+
+#: C/messagedialog.vala.page:32(link)
+msgid "Gtk.MessageType"
+msgstr "Gtk.MessageType"
+
+#: C/messagedialog.vala.page:33(link)
+msgid "Gtk.ButtonsType"
+msgstr "Gtk.ButtonsType"
+
+#: C/messagedialog.py.page:21(p)
+msgid ""
+"A message dialog which prints messages on the terminal, depending on your "
+"choices."
+msgstr ""
+"ÎÎÎÏ ÎÎÎÎÎÎÎÏ ÎÎÎÏÎÎÏÎÏ ÏÎÏ ÏÏÏÏÎÎÎ ÎÎÎÏÎÎÏÎ ÏÏÎ ÏÎÏÎÎÏÎÎÏ, ÎÎÎÎÎÎÎ ÎÎ ÏÎÏ "
+"ÎÏÎÎÎÎÎÏ ÏÎÏ."
+
+#: C/messagedialog.js.page:16(desc)
+msgid "A modal message window"
+msgstr "ÎÎÎ ÎÏÎÎÎÎÎÏÏÎÎÏ ÏÎÏÎÎÏÏÎ ÎÎÎÏÎÎÏÎÏ"
+
+#: C/messagedialog.js.page:21(p)
+msgid "A modal message dialog. This one can cause the world to explode."
+msgstr ""
+"ÎÎÎÏ ÎÏÎÎÎÎÎÏÏÎÎÏÏ ÎÎÎÎÎÎÎÏ ÎÎÎÏÎÎÏÎÏ. ÎÏÏÏÏ ÎÏÎÏÎÎ ÎÎ ÏÏÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÏÎÎÎ "
+"ÏÎÏ ÎÏÏÎÎÏ."
+
+#: C/messagedialog.js.page:28(link) C/gmenu.vala.page:24(title)
+#: C/gmenu.py.page:19(title) C/gmenu.py.page:30(link)
+#: C/gmenu.js.page:19(title) C/gmenu.js.page:28(link) C/gmenu.c.page:19(title)
+#: C/gmenu.c.page:30(link) C/aboutdialog.js.page:27(link)
+msgid "GMenu"
+msgstr "GMenu"
+
+#: C/messagedialog.js.page:29(link) C/gmenu.py.page:31(link)
+#: C/gmenu.js.page:29(link) C/gmenu.c.page:31(link)
+#: C/aboutdialog.js.page:28(link)
+msgid "GSimpleAction"
+msgstr "GSimpleAction"
+
+#: C/messagedialog.js.page:31(link) C/linkbutton.js.page:29(link)
+#: C/label.vala.page:30(link) C/label.js.page:29(link)
+#: C/GtkApplicationWindow.vala.page:30(link)
+#: C/GtkApplicationWindow.js.page:30(link) C/grid.py.page:31(link)
+#: C/grid.js.page:33(link) C/gmenu.vala.page:40(link)
+#: C/dialog.js.page:29(link) C/button.js.page:30(link)
+#: C/aboutdialog.vala.page:36(link) C/aboutdialog.js.page:31(link)
+msgid "Gtk.ApplicationWindow"
+msgstr "Gtk.ApplicationWindow"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/message-board.c.page:36(None)
+msgid ""
+"@@image: 'media/message-board.ogv'; md5=beb80c4538776dc2cdd26c95abea5027"
+msgstr ""
+"@@image: 'media/message-board.ogv'Â md5=beb80c4538776dc2cdd26c95abea5027"
+
+#: C/message-board.c.page:10(desc)
+msgid "A simple program using WebKitGTK+ and the DOM."
+msgstr "ÎÎÎ ÎÏÎÏ ÏÏÏÎÏÎÎÎÎ ÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎ WebKitGTK+ ÎÎÎ ÏÎ DOM."
+
+#: C/message-board.c.page:14(name) C/index.page:12(name)
+msgid "Shaun McCance"
+msgstr "Shaun McCance"
+
+#: C/message-board.c.page:15(email) C/index.page:13(email)
+#| msgid "jhs gnome org"
+msgid "shaunm gnome org"
+msgstr "shaunm gnome org"
+
+#: C/message-board.c.page:16(years) C/index.page:14(years)
+msgid "2010"
+msgstr "2010"
+
+#: C/message-board.c.page:21(title)
+msgid "Message Board"
+msgstr "ÎÎÎÎÎÎÏ ÎÎÎÏÎÎÏÎÏ"
+
+#: C/message-board.c.page:26(p)
+msgid "How to display a web page with WebKit."
+msgstr "ÎÏÏ ÎÎ ÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÏÏÎÏÎÎÎÎÎ ÎÎ WebKit."
+
+#: C/message-board.c.page:27(p)
+msgid ""
+"How to manipulate the contents of a web page using WebKit's DOM functions."
+msgstr ""
+"ÎÏÏ ÎÎ ÏÎÎÏÎÏÏÎÎÏÎ ÏÎ ÏÎÏÎÎÏÏÎÎÎÎ ÎÎÎÏ ÎÏÏÎÏÎÎÎÎÎÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÏ "
+"ÏÏÎÎÏÏÎÏÎÎÏ DOM ÏÎÏ WebKit."
+
+#: C/message-board.c.page:30(p)
+msgid ""
+"This tutorial assumes you are familiar with the C programming language and "
+"have a basic understanding of GTK+, including how to create and place "
+"widgets and how to connect callback functions to signals. See <link xref="
+"\"image-viewer.c\"/> to learn the basics of GTK+."
+msgstr ""
+"ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ ÏÏÎÎÎÏÎÎ ÎÎÎÎÎÎÎÏÏÎ ÎÎ ÏÎ ÎÎÏÏÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ C ÎÎÎ ÎÎÏÎÎÎ "
+"ÎÎÏÎÎÏÎÏÎ ÏÎÏ GTK+, ÏÏÎÏÎÏÎÎÎÎÎÎÎÏÎÎÎÎÏ ÏÎÏ ÎÎÎÎÎÏÏÎÎÎÏ ÎÎÎ ÏÎÏÎÎÎÏÎÏÎÏ "
+"ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ ÎÎÎ ÏÎÏ ÏÏÎÎÎÏÎÏ ÏÏÎÎÏÏÎÏÎÏÎ ÎÏÎÎÎÎÎÎÏÎÏ ÏÎ ÏÎÎÎÏÎ. "
+"ÎÎÎÏÎ <link xref=\"image-viewer.c\"/> ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎ ÎÎÏÎÎÎ ÏÎÏ GTK+."
+
+#: C/message-board.c.page:43(p)
+msgid ""
+"The GNOME platform includes WebKitGTK+, built on top of the powerful WebKit "
+"HTML framework. WebKit is used throughout GNOME, not just to view web pages "
+"on the Internet, but also to create rich user interfaces that can be easily "
+"styled with CSS."
+msgstr ""
+"ÎÎ GNOME ÏÎÏÎÎÏÎÎ ÏÎ WebKitGTK+, ÎÎÏÎÏÎÎÏÎÏÎÎÎÎ ÏÎÎÏ ÏÏÎÎ ÎÏÏÏÏÏ ÏÎÎÎÎÏÏ ÏÎÏ "
+"WebKit HTML. ÎÎ WebKit ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÏÎ ÎÏÏ ÏÎ GNOME, ÏÏÎ ÎÏÎÎ ÎÎÎ "
+"ÏÏÎÎÎÎÎ ÎÏÏÎÏÎÎÎÎÏÎ ÏÏÎ ÎÎÎÎÎÎÏÏÎ, ÎÎÎÎ ÎÏÎÏÎÏ ÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÏÎÎÏÏÎÏÎ "
+"ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ ÏÎÏ ÎÏÎÏÎÏÎ ÎÏÎÎÎÎ ÎÎ ÎÎÏÏÎÏÎÎÎÎÎÏÎ ÎÎ CSS."
+
+#: C/message-board.c.page:48(p)
+msgid ""
+"In this tutorial, you will create a simple message board using WebKit. The "
+"message board will allow you to enter some text and have it added to a list "
+"of messages in HTML. Before you begin, you need to set up a project in "
+"Anjuta."
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ, ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎ ÎÏÎÏ ÏÎÎÎÎÎ ÎÎÎÏÎÎÏÎÏ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ WebKit. Î ÏÎÎÎÎÎÏ ÎÎÎÏÎÎÏÎÏ ÎÎ ÎÏÎÏÏÎÏÎÎ ÏÎÎ ÎÎÏÎÎÏÎÎ "
+"ÎÎÏÎÎÎÏ ÎÎÎÎÎÎÎÏ ÎÎÎ ÏÎÎ ÏÏÎÏÎÎÎÎ ÏÎÏ ÏÎ ÎÎÎ ÎÎÏÏÎ ÎÎÎÏÎÎÏÏÎ ÏÎ HTML. ÎÏÎÎ "
+"ÏÎÎ ÎÎÎÎÎÎÏÎ, ÏÏÎÎÎÎÏÏÎÏÏÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎ ÎÏÎÎ ÏÏÎ Anjuta."
+
+#: C/message-board.c.page:54(p)
+#| msgid ""
+#| "Start Anjuta and click <guiseq><gui>File</gui><gui>New</gui><gui>Project</"
+#| "gui></guiseq> to open the project wizard."
+msgid ""
+"In Anjuta, click <guiseq><gui>File</gui><gui>New</gui><gui>Project</gui></"
+"guiseq> to open the new project assistant."
+msgstr ""
+"ÎÏÎ Anjuta, ÎÎÎÎ "
+"<guiseq><gui>ÎÏÏÎÎÎ</gui><gui>ÎÎÎ</gui><gui>ÎÏÎÎ</gui></guiseq> ÎÎÎ ÎÎ "
+"ÎÎÎÎÎÎÏÎ ÏÎÎ ÎÎÎ ÎÎÎÎÏ ÎÏÎÎÏ."
+
+#: C/message-board.c.page:56(p)
+msgid ""
+"Select <gui>GTK+ (simple)</gui> on the <gui>C</gui> tab, and click "
+"<gui>Continue</gui>."
+msgstr ""
+"ÎÏÎÎÎÎÏÎ <gui>GTK+ (ÎÏÎÏ)</gui> ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>C</gui> ÎÎÎ ÎÎÎÎ "
+"<gui>ÏÏÎÎÏÎÎÎ</gui>."
+
+#: C/message-board.c.page:58(p)
+msgid ""
+"Fill out your details on the <gui>Basic information</gui> page. Use "
+"<input>message-board</input> for the project name. Click <gui>Continue</gui>."
+msgstr ""
+"ÎÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎ ÏÎÎÎÎÎ <gui>ÎÎÏÎÎÎÏ ÏÎÎÏÎÏÎÏÎÎÏ</gui>. "
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ <input>ÏÎÎÎÎÎ ÎÎÎÏÎÎÏÎÏ</input> ÎÎÎ ÏÎ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ. ÎÎÎÎ "
+"<gui>ÏÏÎÎÏÎÎÎ</gui>."
+
+#: C/message-board.c.page:61(p)
+msgid ""
+"Disable the <gui>Use GtkBuilder for user interface</gui> option as this "
+"tutorial builds the user-interface manually."
+msgstr ""
+"ÎÏÎÎÎÏÎÎÏÎÎÎÏÏÎ ÏÎÎ ÎÏÎÎÎÎÎ <gui>ÏÏÎÏÎ GtkBuilder ÎÎÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ</gui> "
+"ÎÎÎÏÏ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ ÎÎÏÎÏÎÎÏÎÎÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÏÎÎÏÎÎÎÎÎÏÎ."
+
+#: C/message-board.c.page:64(p)
+msgid ""
+"You need to tell Anjuta you're using WebKitGTK+ on this project. On the "
+"<gui>Project options</gui> page, select <gui>Configure external packages</"
+"gui>. Click <gui>Continue</gui>. On the <gui>Configure external packages</"
+"gui> page, check <gui>webkitgtk-3.0</gui>."
+msgstr ""
+"ÎÏÎÏÎÎ ÎÎ ÏÎÎÏÎ ÏÏÎ Anjuta ÏÏÎ ÏÏÎÏÎÎÎÏÎÎÎÎÏÎ WebKitGTK+ ÎÎÎ ÎÏÏÏ ÏÎ ÎÏÎÎ. "
+"ÎÏÎ ÏÎÎÎÎÎ <gui>ÎÏÎÎÎÎÎÏ ÎÏÎÎÏ</gui>, ÎÏÎÎÎÎÏÎ <gui>ÏÏÎÎÎÏÎ ÎÎÏÏÎÏÎÎÏÎ "
+"ÏÎÎÎÏÏÎ</gui>. ÎÎÎÎ <gui>ÏÏÎÎÏÎÎÎ</gui>. ÎÏÎ ÏÎÎÎÎÎ <gui>ÏÏÎÎÎÏÎ ÎÎÏÏÎÏÎÎÏÎ "
+"ÏÎÎÎÏÏÎ</gui>, ÏÎÎÎÎÏÏÏÎ <gui>webkitgtk-3.0</gui>."
+
+#: C/message-board.c.page:70(p)
+msgid ""
+"After you finish the new project assistant, open the file <file>src/main.c</"
+"file> from either the <gui>Project</gui> or the <gui>File</gui> tab. Anjuta "
+"will have filled this in with some basic GTK+ code from its templates. Since "
+"you are creating a WebKit project, you first need to include the WebKit "
+"headers. After the line that includes <code>gtk/gtk.h</code>, add the "
+"following line:"
+msgstr ""
+"ÎÏÎÏ ÏÎÎÎÎÏÏÎÏÎ ÎÎ ÏÎÎ ÎÎÎÎÏ ÏÎÏ ÎÎÎÏ ÎÏÎÎÏ, ÎÎÎÎÎÏÎ ÏÎ ÎÏÏÎÎÎ "
+"<file>src/main.c</file> ÎÎÏÎ ÎÏÏ ÏÎ <gui>ÎÏÎÎ</gui> Î ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ "
+"<gui>ÎÏÏÎÎÎ</gui>. ÎÎ Anjuta ÎÎ ÏÎ ÎÎÎÎÏÎÎ ÎÎ ÎÎÏÎÎÎ ÎÎÏÎÎÏ ÎÏÎÎÎÎ GTK+ ÎÏÏ "
+"ÏÎ ÏÏÏÏÏÏÎ ÏÎÏ. ÎÏÎÏ ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÎÎ ÎÏÎÎ WebKit, ÏÏÎÎÎÎÎÏÏÎ ÏÏÏÏÎ ÎÎ "
+"ÏÏÎÏÎÏÎÎÎÎÎÏÎ ÏÎÏ ÎÎÏÎÎÎÎÎÏ WebKit. ÎÎÏÎ ÏÎ ÎÏÎÎÎÎ ÏÎÏ ÏÎÏÎÎÏÎÎ "
+"<code>gtk/gtk.h</code>, ÏÏÎÏÎÎÏÏÎ ÏÎÎ ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎ:"
+
+#: C/message-board.c.page:77(code)
+#, no-wrap
+msgid "#include &lt;webkit/webkit.h&gt;"
+msgstr "#include &lt;webkit/webkit.h&gt;"
+
+#: C/message-board.c.page:79(p)
+msgid ""
+"Verify that everything works by building what you have so far. Click "
+"<guiseq><gui>Build</gui><gui>Build Project</gui></guiseq> or just press "
+"<keyseq><key>Shift</key><key>F7</key></keyseq>. The first time you build, "
+"you will be asked for some configure options. Just accept the defaults and "
+"click <gui>Execute</gui>."
+msgstr ""
+"ÎÏÎÎÎÎÎÎÏÏÏÎ ÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÏÎ ÎÎ ÏÎÎ ÎÎÏÎÏÎÎÏÎ ÏÎÏ ÎÏÎÏÎ ÎÎÎÎÎ ÎÎÏÏÎ ÏÏÏÎ. "
+"ÎÎÎÎ <guiseq><gui>ÎÎÏÎÏÎÎÏÎ</gui><gui>ÎÏÎÎ ÎÎÏÎÏÎÎÏÎÏ</gui></guiseq> Î ÎÏÎÎ "
+"ÏÎÏÎÏÏÎ <keyseq><key>Shift</key><key>F7</key></keyseq>. ÎÎÎ ÏÏÏÏÎ ÏÎÏÎ ÏÎÏ "
+"ÎÎÏÎÏÎÎÏÎÎÎÏÎ, ÎÎ ÏÎÏ ÎÎÏÎÎÎÎ ÎÎÎ ÎÎÏÎÎÎÏ ÎÏÎÎÎÎÎÏ ÏÏÎÎÎÏÎÏ. ÎÏÎÎ "
+"ÎÏÎÎÎÏÏÎÎÏÎ ÏÎÏ ÏÏÎÎÏÎÎÎÎÎÏ ÎÎÎ ÎÎÎÎ <gui>ÎÎÏÎÎÎÏÎ</gui>."
+
+#: C/message-board.c.page:85(p)
+#| 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."
+msgid ""
+"You should now be able to run the program. Click <guiseq><gui>Run</"
+"gui><gui>Execute</gui></guiseq> or just press <key>F3</key>. You should see "
+"an empty window appear."
+msgstr ""
+"ÎÏÏÎ ÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÎÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ. ÎÎÎÎ "
+"<guiseq><gui>ÏÏÎÎÎÎÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq> Î ÎÏÎÎ ÏÎÏÎÏÏÎ "
+"<key>F3</key>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÎÎ ÎÎÎÎÎ ÏÎÏÎÎÏÏÎ."
+
+#: C/message-board.c.page:91(title)
+msgid "Lay out your window and web view"
+msgstr "ÎÎÎÏÎÎÏÎÏÎ ÏÎÏ ÏÎÏÎÎÏÏÎÏ ÏÎÏ ÎÎÎ ÏÏÎÎÎÎÎ ÎÏÏÎÏ"
+
+#: C/message-board.c.page:93(p)
+msgid ""
+"Now that you can show a window, it's time to start working with WebKit. For "
+"this tutorial, you'll create a text entry and a web view and pack them both "
+"into a window. Find the function <code>create_window</code> and replace it "
+"with the following:"
+msgstr ""
+"ÎÏÏÎ ÏÎÏ ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÏÎ ÎÎÎ ÏÎÏÎÎÏÏÎ, ÎÎÎÎÎ ÎÎÎÏÏÏ ÎÎ ÎÎÎÎÎÎÏÎÏÎ ÎÎÏÎÎÎÎ "
+"ÎÎ ÏÎ WebKit. ÎÎÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ, ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÎÎÏÎÏÏÏÎÏÎ ÎÎÎÎÎÎÎÏ "
+"ÎÎÎ ÎÎÎ ÏÏÎÎÎÎÎ ÎÏÏÎÏ ÎÎÎ ÏÎÎÎÏÎÏÎÏÎÎ ÏÎÏÏ ÏÎ ÎÎÎ ÏÎÏÎÎÏÏÎ. ÎÏÎÎÏÎ ÏÎ "
+"ÏÏÎÎÏÏÎÏÎ <code>create_window</code> ÎÎÎ ÎÎÏÎÎÎÏÎÏÏÎÏÏÎ ÏÎÎ ÎÎ ÏÎÎ ÏÎÏÎÎÎÏÏ:"
+
+#: C/message-board.c.page:133(p)
+msgid ""
+"You first create a <code>GtkWindow</code> object and set its title and "
+"default size. You also connect the <code>gtk_main_quit</code> function to "
+"the <code>delete-event</code> signal. The <code>delete-event</code> signal "
+"is emitted when the window is closed. The <code>gtk_main_quit</code> "
+"function is part of GTK, and it quits the application."
+msgstr ""
+"ÎÎÎÎÎÏÏÎÎÏÏÎ ÏÏÏÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ <code>GtkWindow</code> ÎÎÎ ÎÏÎÏÏÎ ÏÎÎ "
+"ÏÎÏÎÎ ÏÎÏ ÏÏÎÎÏÎÎÎÎÎÎÎÎ ÎÎÎÎÎÎÏ. ÎÏÎÎÎÏÏÎ ÎÏÎÏÎÏ ÏÎ ÏÏÎÎÏÏÎÏÎ "
+"<code>gtk_main_quit</code> ÎÎ ÏÎ ÏÎÎÎ <code>delete-event</code>. ÎÎ ÏÎÎÎ "
+"<code>delete-event</code> ÎÎÏÎÎÏÎÏÎÎ ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÎÎ. Î ÏÏÎÎÏÏÎÏÎ "
+"<code>gtk_main_quit</code> ÎÎÎÎÎ ÏÎÎÎÎ ÏÎÏ GTK ÎÎÎ ÎÎÎÎÏÎÎÎÎÏÎÎ ÏÎÎ "
+"ÎÏÎÏÎÎÎÎ."
+
+#: C/message-board.c.page:139(p)
+msgid ""
+"You then create a vertical box and add it to the window. A window can only "
+"hold a single child widget, so you need to use a box to add multiple "
+"widgets. The second argument to <code>gtk_box_new</code> sets the amount of "
+"padding (in pixels) between each child, and the next line puts a six-pixel "
+"border around the entire thing."
+msgstr ""
+"ÎÏÎÎÏÎ ÎÎÎÎÎÏÏÎÎÏÏÎ ÎÎÎ ÎÎÎÎÏÎ ÏÎÎÎÏÎÎ ÎÎÎ ÏÏÎÏÎÎÏÏÎ ÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ. ÎÎÎ "
+"ÏÎÏÎÎÏÏÎ ÎÏÎÏÎÎ ÎÎ ÎÏÎÏÎ ÎÏÎÎ ÎÎÎ ÎÎÎÎÎÎÎÏ ÎÎÏÎÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ, ÎÏÏÎ "
+"ÏÏÎÎÎÎÏÏÎÏÏÎ ÏÎ ÏÏÎÏÎ ÎÎÏÏ ÏÎÎÎÏÎÎÏ ÎÎÎ ÏÏÎÏÎÎÎÎ ÏÎÎÎÎÏÎÏÎ ÎÏÎÏÎÎÏÎ "
+"ÏÏÏÏÎÏÎÎÏÎ. ÎÎ ÎÎÏÏÎÏÎ ÏÏÎÏÎÎ ÏÏÎ <code>gtk_box_new</code> ÎÏÎÎÎÎ ÏÎÎ "
+"ÏÎÏÏÏÎÏÎ ÏÏÎÏÎÎÏÏÏÎÏ (ÏÎ ÎÎÎÎÎÎÏÏÎÎÏÎÎÎ) ÎÎÏÎÎÏ ÎÎÎÎ ÎÎÏÎÏÎÏÎÏ ÎÎÎ Î ÎÏÏÎÎÎÎ "
+"ÎÏÎÎÎÎ ÎÎÎÎÎ ÎÎÎ ÏÎÏÎÎÏÎÎÎÎ ÎÎÎ ÎÎÎÎÎÎÏÏÎÎÏÎÎÏÎ ÎÏÏÏ ÎÏÏ ÏÎÎ ÏÎ "
+"ÎÎÏÎÎÎÎÎÎÎÎ."
+
+#: C/message-board.c.page:145(p)
+msgid ""
+"You next create a <code>GtkEntry</code> object and pack it into the box. The "
+"third and fourth arguments to <code>gtk_box_pack_start</code> specify that "
+"the entry shouldn't take up any extra space the box has available. The "
+"fourth argument is the amount of padding you want around the entry. In this "
+"case, you set the padding to zero, because you're allowing the box to handle "
+"all the padding."
+msgstr ""
+"ÎÏÎÎÏÎ ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ <code>GtkEntry</code> ÎÎÎ ÏÎ ÏÎÎÎÏÎÏÎÏÎ "
+"ÏÏÎ ÏÎÎÎÏÎÎ. ÎÎ ÏÏÎÏÎ ÎÎÎ ÏÎÏÎÏÏÎ ÏÏÎÏÎÎ ÏÏÎ <code>gtk_box_pack_start</code> "
+"ÎÎÎÎÏÎÎÎÎ ÏÏÎ Î ÎÎÏÎÏÏÏÎÏÎ ÎÎÎ ÎÎ ÏÏÎÏÎÎ ÎÎ ÏÎÏÎÎ ÎÏÎÏÎÎÎÎ ÏÏÏÎ ÏÎÏ ÏÎ "
+"ÏÎÎÎÏÎÎ ÎÏÎÎ ÎÎÎÎÎÏÎÎÎ. ÎÎ ÏÎÏÎÏÏÎ ÏÏÎÏÎÎ ÎÎÎÎÎ Î ÏÎÏÏÏÎÏÎ ÏÏÎÏÎÎÏÏÏÎÏ ÏÎÏ "
+"ÎÎÎÎÏÎ ÎÏÏÏ ÎÏÏ ÏÎÎ ÎÎÏÎÏÏÏÎÏÎ. ÎÎ ÎÏÏÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ, ÎÏÎÎÎÏÎ ÏÎ ÏÏÎÏÎÎÏÏÏÎ "
+"ÏÎ ÎÎÎÎÎ, ÎÏÎÎÎÎ ÎÏÎÏÏÎÏÎÏÎ ÏÏÎ ÏÎÎÎÏÎÎ ÎÎ ÏÎÎÏÎÏÏÎÎ ÏÎÎ ÏÎ ÏÏÎÏÎÎÏÏÏÎ."
+
+#: C/message-board.c.page:152(p)
+msgid ""
+"Before you add a web view, you have to create a scrolled window to put it "
+"inside of. The scrolled window will place scrollbars on the right and bottom "
+"when necessary, and prevent your web view from filling your entire screen. "
+"This time, you pass <code>TRUE</code> and <code>TRUE</code> to "
+"<code>gtk_box_pack_start</code> to allow the scrolled window (and thus, the "
+"web view) to use any extra space available in the box."
+msgstr ""
+"ÎÏÎÎ ÏÎÎ ÏÏÎÏÎÎÎÎ ÎÎÎÏ ÏÏÎÎÎÎÎÏ ÎÏÏÎÏ, ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎ ÎÏÎÎÏÎÎÎÎ "
+"ÏÎÏÎÎÏÏÎ ÎÎÎ ÎÎ ÎÏÎÎ ÎÎÏÎ ÏÎÏ. ÎÎ ÎÏÎÎÏÎÎÎÎ ÏÎÏÎÎÏÏÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÎ ÎÏÎÎÎÎÏ "
+"ÎÏÎÎÏÎÏ ÏÏÎ ÎÎÎÎÎ ÎÎÎ ÎÎÏÏ ÏÏÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÏÎÏÏÎÏÎÎ ÏÎÎ ÏÏÎÎÎÎÎ ÏÎÏ "
+"ÎÏÏÎÏ ÎÏÏ ÏÎ ÎÎÎÎÏÎÎ ÏÎÎÏ ÏÎÏ ÎÎÏÎÎÏ. ÎÏÏÎ ÏÎ ÏÎÏÎ, ÏÎÏÎÎÏÎ "
+"<code>TRUE</code> ÎÎÎ <code>TRUE</code> ÏÏÎ <code>gtk_box_pack_start</code> "
+"ÎÎÎ ÎÎ ÎÏÎÏÏÎÏÎÏÎ ÏÏÎ ÎÏÎÎÏÎÎÎÎ ÏÎÏÎÎÏÏÎ (ÎÎÎ ÏÏÎÎÏÏÏ ÏÏÎÎ ÏÏÎÎÎÎÎ ÎÏÏÎÏ) ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÎÏÎÎÎÎÎÏÎÏÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ ÏÏÎ ÏÎÎÎÏÎÎ."
+
+#: C/message-board.c.page:159(p)
+msgid ""
+"Finally, you create a <code>WebKitWebView</code> and add it to the scrolled "
+"window. Then load a very basic HTML page into the web view by calling "
+"<code>webkit_web_view_load_string</code> with the following arguments:"
+msgstr ""
+"ÎÎÎÎÎÎ, ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÎÎ <code>WebKitWebView</code> ÎÎÎ ÏÎ ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ "
+"ÎÏÎÎÏÎÎÎÎ ÏÎÏÎÎÏÏÎ. ÎÏÎÎÏÎ ÏÎÏÏÏÎÎÏÎ ÎÎÎ ÏÎÎÏ ÎÎÏÎÎÎ ÏÎÎÎÎÎ HTML ÏÏÎÎ "
+"ÏÏÎÎÎÎÎ ÎÏÏÎÏ ÎÎÎÏÎÏÎÏ <code>webkit_web_view_load_string</code> ÎÎ ÏÎ "
+"ÏÎÏÎÎÎÏÏ ÎÏÎÏÎÎÏÎ:"
+
+#: C/message-board.c.page:165(code)
+#, no-wrap
+msgid "WEBKIT_WEB_VIEW (view)"
+msgstr "WEBKIT_WEB_VIEW (ÏÏÎÎÎÎÎ)"
+
+#: C/message-board.c.page:166(p)
+msgid ""
+"The view itself. Because <code>view</code> is typed as a <code>GtkWidget*</"
+"code>, you have to use <code>WEBKIT_WEB_VIEW</code> to safely cast the "
+"object."
+msgstr ""
+"Î ÎÎÎÎ Î ÏÏÎÎÎÎÎ. ÎÏÎÎÎÎ Î <code>view</code> ÏÎÎÎÏÏÎÎÎÎÎÎÏÎ ÏÏ "
+"<code>GtkWidget</code>, ÏÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ "
+"<code>WEBKIT_WEB_VIEW</code> ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÎÎÎ ÏÎÏ ÎÎÏÎÎÎÎÎÎÎÎÏ."
+
+#: C/message-board.c.page:171(code)
+#, no-wrap
+msgid "\"&lt;html&gt;&lt;body&gt;&lt;/body&gt;&lt;/html&gt;\""
+msgstr "\"&lt;html&gt;&lt;body&gt;&lt;/body&gt;&lt;/html&gt;\""
+
+#: C/message-board.c.page:172(p)
+msgid "The simplest HTML file you could possibly write."
+msgstr "ÎÎ ÎÏÎÎÏÏÏÎÏÎ ÎÏÏÎÎÎ HTML ÏÎÏ ÎÎ ÎÏÎÏÎÏÏÎÏÎ ÎÎ ÎÏÎÏÎÏÎ."
+
+#: C/message-board.c.page:175(code)
+#, no-wrap
+msgid "\"text/html\""
+msgstr "\"text/html\""
+
+#: C/message-board.c.page:176(p)
+msgid ""
+"The MIME type of the content you provided. In this case, you're using plain "
+"HTML."
+msgstr ""
+"Î ÏÏÏÎÏ MIME ÏÎÏ ÏÎÏÎÎÏÎÎÎÎÎÏ ÏÎÏ ÎÎÎÎÏÎ. ÎÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ, "
+"ÏÏÎÏÎÎÎÏÎÎÎÎÏÎ ÎÏÎÏ HTML."
+
+#: C/message-board.c.page:180(code)
+#, no-wrap
+msgid "\"UTF-8\""
+msgstr "\"UTF-8\""
+
+#: C/message-board.c.page:181(p)
+msgid ""
+"The character encoding of the content you provided. Although you only used "
+"ASCII characters, it's a good idea to specify UTF-8. UTF-8 is used as the "
+"default encoding throughout the GNOME platform."
+msgstr ""
+"Î ÎÏÎÎÎÎÏÎÎÎÏÎ ÏÎÏÎÎÏÎÏÎ ÏÎÏ ÏÎÏÎÏÏÎÎÎÎÏ ÏÎÏÎÎÏÎÎÎÎÎÏ. ÎÎ ÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÏÎ "
+"ÎÏÎÎ ASCII ÏÎÏÎÎÏÎÏÎÏ, ÎÎÎÎÎ ÎÎÎÎ Î ÎÎÎÎÏÎÏÎÏÏ UTF-8. ÎÎ UTF-8 "
+"ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÏÏ Î ÏÏÎÎÏÎÎÎÎÎÎÎÎ ÎÏÎÎÎÎÏÎÎÎÏÎ ÎÎÎÎÎÎÏÏÏÎÎÎ ÏÏÎ GNOME."
+
+#: C/message-board.c.page:186(code)
+#, no-wrap
+msgid "NULL"
+msgstr "NULL"
+
+#: C/message-board.c.page:187(p)
+msgid ""
+"The base URI. You don't need it in this simple example, but you might want "
+"to provide a <sys>file:</sys> URI if you add images or other features where "
+"you want to use relative URI references."
+msgstr ""
+"Î ÎÎÏÎ URI. ÎÎÎ ÏÎÎ ÏÏÎÎÎÎÏÏÎÏÏÎ ÏÎ ÎÏÏÏ ÏÎ ÎÏÎÏ ÏÎÏÎÎÎÎÎÎÎ, ÎÎÎÎ ÎÏÏÏ "
+"ÎÎÎÎÏÎÏÎ ÎÎ ÎÏÏÎÏÎ ÎÎÎ <sys>file:</sys> URI ÎÎÎ ÏÏÎÏÎÎÏÎÏÎ ÎÎÎÏÎÎÏ Î ÎÎÎÎ "
+"ÏÎÏÎÎÏÎÏÎÏÏÎÎÎ ÏÎÏ ÎÎÎÎÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÏÎÏÎÎÎÏ ÎÎÎÏÎÏÎÏ URI."
+
+#: C/message-board.c.page:194(p)
+msgid ""
+"Every time you add a widget, you have to call <code>gtk_widget_show</code> "
+"on it for it to be visible. If you call <code>gtk_widget_show_all</code> on "
+"a container widget like a <code>GtkBox</code>, GTK+ will automatically show "
+"all the widgets inside the container, to any depth. Sometimes you don't want "
+"to call <code>gtk_widget_show_all</code>, such as when you want to "
+"dynamically hide and show some widgets in response to events."
+msgstr ""
+"ÎÎÎÎ ÏÎÏÎ ÏÎÏ ÏÏÎÏÎÎÏÎÏÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ, ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÏÎÏÎ "
+"<code>gtk_widget_show</code> ÎÎÎ ÎÎ ÎÎÎÎÎ ÎÏÎÏÏ. ÎÎÎ ÎÎÎÎÏÎÏÎ "
+"<code>gtk_widget_show_all</code> ÏÎ ÎÎÎ ÏÎÏÎÎÎÏÎ ÎÏÎÏÎÎÎÏ ÏÏÏÏÎÏÎÎÎÏ ÏÏÏÏ "
+"<code>GtkBox</code>, ÏÎ GTK+ ÎÎ ÎÎÏÎÎÎÏÎÎ ÎÏÏÏÎÎÏÎ ÏÎÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ "
+"ÎÎÏÎ ÏÏÎÎ ÏÎÏÎÎÎÏÎ, ÏÎ ÎÏÎÎÎÎÎÏÎÏÎ ÎÎÎÎÏ. ÎÎÏÎÎÎÏ ÏÎÏÎÏ ÎÎÎ ÎÎÎÎÏÎ ÎÎ "
+"ÎÎÎÎÏÎÏÎ <code>gtk_widget_show_all</code>, ÏÏÏÏ ÏÏÎÎ ÎÎÎÎÏÎ ÎÎ ÎÏÏÏÎÏÎ "
+"ÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÏÎ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÎ ÎÏÎÎÏÎÏÎ ÏÏÎÎÎÎÏÏÎ."
+
+#: C/message-board.c.page:202(p)
+msgid ""
+"Finally, you have to call <code>gtk_widget_show_all</code> on the box. "
+"Otherwise, none of the widgets you created will be visible. (The window is "
+"shown in the <code>main</code> function with <code>gtk_widget_show</code>.)"
+msgstr ""
+"ÎÎÎÎÎÎ, ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÏÎÏÎ <code>gtk_widget_show_all</code> ÏÏÎ ÏÎÎÎÏÎÎ. "
+"ÎÎÎÎÏÏ, ÎÎÎÎÎÎ ÎÏÏ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÎÏ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎ ÎÎ ÎÎÎÎÎ "
+"ÎÏÎÏÏ. (ÎÎ ÏÎÏÎÎÏÏÎ ÎÎÏÎÎÎÎÎÏÎÎ ÏÏÎ ÏÏÎÎÏÏÎÏÎ <code>main</code> ÎÎ "
+"<code>gtk_widget_show</code>.)"
+
+#: C/message-board.c.page:206(p)
+msgid ""
+"Build and run the message board again. You should see a window with a text "
+"entry and a web view. It doesn't do anything yet because the text entry and "
+"the web view don't know anything about each other."
+msgstr ""
+"ÎÎÏÎÏÎÎÏÎ ÎÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÏÎÎÎÎÎ ÎÎÎÏÎÎÏÎÏ ÎÎÎÎ. ÎÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÎÎ "
+"ÏÎÏÎÎÏÏÎ ÎÎ ÎÎÏÎÏÏÏÎÏÎ ÎÎÎÎÎÎÎÏ ÎÎÎ ÎÎÎ ÏÏÎÎÎÎÎ ÎÏÏÎÏ. ÎÎÎ ÎÎÎÎÎ ÏÎÏÎÏÎ "
+"ÎÎÏÎÎ, ÎÏÎÎÎÎ Î ÎÎÏÎÏÏÏÎÏÎ ÎÎÎÎÎÎÎÏ ÎÎÎ Î ÏÏÎÎÎÎÎ ÎÏÏÎÏ ÎÎÎ ÎÎÏÎÏÎ ÏÎÏÎÏÎ "
+"ÎÎÏÎÎÏ ÏÎÏÏ."
+
+#: C/message-board.c.page:212(title)
+msgid "Hook up signals"
+msgstr "ÎÏÎÎÎÏÎ ÏÎÎÎÏÏÎ"
+
+#: C/message-board.c.page:214(p)
+msgid ""
+"Now you want to make the message board actually <em>do</em> something when "
+"you enter text into the text entry. To do this, connect a callback function "
+"to the <code>activate</code> signal of <code>entry</code>. GTK+ emits the "
+"<code>activate</code> signal whenever the user presses <key>Enter</key> in "
+"the entry. Add the following into <code>create_window</code>, anywhere after "
+"both <code>entry</code> and <code>view</code> have been defined:"
+msgstr ""
+"ÎÏÏÎ, ÎÎÎÎÏÎ ÎÎ ÎÎÎÎÏÎ ÏÎÎ ÏÎÎÎÎÎ ÎÎÎÏÎÎÏÎÏ ÏÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎÏÎ <em>ÎÎ "
+"ÎÎÎÎÎ</em> ÎÎÏÎ ÏÏÎÎ ÎÎÏÎÎÎÏÎ ÎÎÎÎÎÎÎ ÏÏÎÎ ÎÎÏÎÏÏÏÎÏÎ ÎÎÎÎÎÎÎÏ. ÎÎÎ ÎÎ ÏÎ "
+"ÎÎÎÎÏÎ ÎÏÏÏ, ÏÏÎÎÎÏÏÎ ÎÎÎ ÏÏÎÎÏÏÎÏÎ ÎÏÎÎÎÎÎÎÏÎÏ ÏÏÎ ÏÎÎÎ "
+"<code>activate</code> ÏÎÏ <code>entry</code>. ÎÎ GTK+ ÎÎÏÎÎÏÎÎ ÏÎ ÏÎÎÎ "
+"<code>activate</code> ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎ <key>Enter</key> ÏÏÎÎ ÎÎÏÎÏÏÏÎÏÎ. "
+"ÎÏÎÏÎÎÏÏÎ ÏÎ ÏÎÏÎÎÎÏÏ ÏÏÎ <code>create_window</code>, ÎÏÎÏÎÎÏÎÏÎ ÎÏÎÏ ÎÎÎ "
+"<code>entry</code> ÎÎÎ <code>view</code> ÎÏÎÏÏÎÏÎ:"
+
+#: C/message-board.c.page:225(p)
+msgid ""
+"You then have to actually define <code>entry_activate_cb</code>. Define it "
+"as follows, anywhere above <code>create_window</code>:"
+msgstr ""
+"ÎÏÏÎ ÏÏÎÏÎÎ ÏÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎÏÎ ÎÎ ÎÏÎÏÎÏÎ <code>entry_activate_cb</code>. "
+"ÎÏÎÏÏÎ ÏÎ ÏÏÏÏ ÎÎÎÎÎÏÎÎÎ, ÎÏÎÏÎÎÏÎÏÎ ÏÎÎÏ ÎÏÏ <code>create_window</code>:"
+
+#: C/message-board.c.page:248(p)
+msgid ""
+"The first thing you do is get a <code>WebKitDOMDocument</code> object that "
+"represents the HTML document displayed in <code>view</code>. The DOM classes "
+"and methods in WebKit allow you to inspect and manipulate the HTML document, "
+"and work very similarly to the DOM APIs you might already know from "
+"JavaScript."
+msgstr ""
+"ÎÎ ÏÏÏÏÎ ÏÏÎÎÎÎ ÎÎÎÎÎ ÎÎ ÏÎÏÎÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ "
+"<code>WebKitDOMDocument</code> ÏÎÏ ÎÎÏÎÏÏÎÏÏÏÎÏÎÎ ÏÎ ÎÎÏÎÎÎÎÏÎÎÎÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎ <code>view</code>. ÎÎ ÎÎÎÏÎÎÏ DOM ÎÎÎ ÎÎ ÎÎÎÎÎÎÎ ÏÏÎ WebKit ÎÏÎÏÏÎÏÎÏÎ "
+"ÏÎÎ ÎÏÎÎÎÏÏÎÏÎ ÎÎÎ ÏÎÎÏÎÏÎÏ ÏÎÏ ÎÎÎÏÎÏÎÏ HTML ÎÎÎ ÎÎÏÎÎÏÎÏÎ ÏÎÎÏ ÏÎÏÏÎÎÎÎ ÎÎ "
+"ÏÎ APIs DOM ÏÎÏ ÎÎÎ ÎÏÎÏÎÎ ÎÎ ÎÎÏÎÏÎ ÎÏÏ ÏÎ JavaScript."
+
+#: C/message-board.c.page:254(p)
+msgid ""
+"Once you have the document, you want to get the <code>body</code> element so "
+"that you can add <code>div</code> elements to it. The "
+"<code>webkit_dom_document_query_selector</code> function lets you find an "
+"element in the document using CSS selectors. This keeps you from having to "
+"write tedious loops to traverse the document."
+msgstr ""
+"ÎÏÎÎÏ ÎÏÎÏÎ ÏÎ ÎÎÎÏÎÏÎ, ÏÎÎÏÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ <code>body</code>, ÎÏÏÎ ÏÏÏÎ ÎÎ "
+"ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ <code>div</code> ÏÎ ÎÏÏÏ. Î ÏÏÎÎÏÏÎÏÎ "
+"<code>webkit_dom_document_query_selector</code> ÎÏÎÏÏÎÏÎÎ ÏÎÎ ÎÏÏÎÏÎ ÎÎÏÏ "
+"ÏÏÎÎÏÎÎÎÏ ÏÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÎÏÎÎÎÎÎÎÏ CSS. ÎÏÏÏ ÏÎÏ ÎÎÏÏÏÎÎÎ ÎÏÏ "
+"ÏÎ ÎÏÎÏÎÎÎ ÎÎÏÏÎÏÏÎÎÏÎ ÎÏÏÏÏÎ ÎÎÎ ÏÎÏÎÏÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ."
+
+#: C/message-board.c.page:261(cite) C/message-board.c.page:273(cite)
+#: C/message-board.c.page:325(cite) C/message-board.c.page:382(cite)
+#: C/message-board.c.page:390(cite)
+msgid "shaunm"
+msgstr "shaunm"
+
+#: C/message-board.c.page:262(p)
+msgid "FIXME: Is this true? Does query_selector take CSS, CSSish, or what?"
+msgstr "ÎÎÎÎÎÎÎÎ: ÎÎÎÎÎ ÎÎÎÎÎÎÎ; ÎÎ query_selector ÏÎÎÏÎÎÎ CSS, CSSish Î ÏÎ;"
+
+#: C/message-board.c.page:265(p)
+msgid ""
+"Next, you create a new <code>div</code> element to hold the message. Every "
+"element you create has to be attached to a document, so the function to "
+"create an element takes the <code>WebKitDOMDocument</code> as its first "
+"arguments. You then set the text content of the element to the contents of "
+"the text entry. Because <code>gtk_entry_get_text</code> returns a "
+"<code>const gchar*</code>, you don't have to free the result."
+msgstr ""
+"ÎÎÏÎ, ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÎÎ ÎÎÎ ÏÏÎÎÏÎÎÎ <code>div</code> ÎÎÎ ÎÏÎÏÎÎÎ ÏÎÏ "
+"ÎÎÎÏÎÎÏÎÏ. ÎÎÎÎ ÏÏÎÎÏÎÎÎ ÏÎÏ ÎÎÎÎÎÏÏÎÎÎÏÎ ÏÏÎÏÎÎ ÎÎ ÏÏÎÏÎÏÏÎÎÎÎ ÏÎ ÎÎÎ "
+"ÎÎÎÏÎÏo, ÎÏÏÎ Î ÏÏÎÎÏÏÎÏÎ ÏÏÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÏÏ ÏÏÎÎÏÎÎÎÏ ÏÎÎÏÎÎÎ ÏÎ "
+"<code>WebKitDOMDocument</code> ÏÏ ÏÎ ÏÏÏÏÎ ÏÎÏ ÎÏÎÏÎÎÏÎ. ÎÏÎÎÏÎ ÎÏÎÎÎÏÎ ÏÎ "
+"ÏÎÏÎÎÏÏÎÎÎÎ ÎÎÎÎÎÎÎÏ ÏÎÏ ÏÏÎÎÏÎÎÎÏ ÏÏÎ ÏÎÏÎÎÏÏÎÎÎÎ ÏÎÏ ÎÎÏÎÏÏÏÎÏÎÏ ÎÎÎÎÎÎÎÏ. "
+"ÎÏÎÎÎÎ ÏÎ <code>gtk_entry_get_text</code> ÎÏÎÏÏÏÎÏÎÎ ÏÎ <code>const "
+"gchar*</code>, ÎÎÎ ÏÏÎÏÎÎ ÎÎ ÎÏÎÎÎÏÎÎÏÏÏÎÏÎ ÏÎ ÎÏÎÏÎÎÎÏÎÎ."
+
+#: C/message-board.c.page:274(p)
+msgid ""
+"Not passing the GError**, but we should give it a quick mention and link to "
+"somewhere that explains how GError-handling works."
+msgstr ""
+"ÎÎ ÎÎÎ ÏÎÏÎÎÏÎ ÏÎ GError**, ÎÎÎÎ ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ ÏÎÏ ÎÏÏÎÏÎÎ ÎÎÎ ÎÏÎÎÎÏÎ "
+"ÎÎÎÏÎÏÎ ÎÎÎ ÏÏÎÎÎÏÎ ÎÎÏÎÏ, ÏÏÎÏ ÎÎÎÎÎÎÏÎÎ ÏÏÏ ÎÎÎÏÎÏÏÎÎÎ Î ÏÎÎÏÎÏÎÏÏ GError."
+
+#: C/message-board.c.page:278(p)
+msgid ""
+"Finally, you append the new <code>div</code> element to the body and clear "
+"out the text entry so you can type something new. Build and run the program "
+"again and test it for yourself."
+msgstr ""
+"ÎÎÎÎÎÎ, ÏÏÎÏÎÏÏÎÏÎ ÏÎ ÎÎÎ ÏÏÎÎÏÎÎÎ <code>div</code> ÏÏÎ ÏÏÎÎ ÎÎÎ ÎÎÎÎÏÎÏÏÎ "
+"ÏÎÎ ÎÎÏÎÏÏÏÎÏÎ ÎÎÎÎÎÎÎÏ, ÎÏÏÎ ÏÏÏÎ ÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÏÏÏÎÏÎ ÎÎÏÎ ÎÎÎ. "
+"ÎÎÏÎÏÎÎÏÎ ÎÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏ ÎÎÎÎ ÎÎÎ ÎÎÎÎÏÎÏ ÏÎÏ ÎÎÎ ÏÎÏ."
+
+#: C/message-board.c.page:285(title)
+msgid "Make it look better with CSS"
+msgstr "ÎÎÎÏÎ ÏÎ ÎÎ ÏÎÎÎÎÏÎÎ ÎÎÎÏÏÎÏÎ ÎÎ CSS"
+
+#: C/message-board.c.page:287(p)
+msgid ""
+"At this point, your program is completely functional, but not very pretty. "
+"You can style the message display with CSS, just like you can with any other "
+"HTML page. There are many ways you could attach some CSS to the page: You "
+"could add it in the initial HTML document. You could inline it in the "
+"<code>style</code> attribute of the <code>div</code> elements. You could "
+"even programmatically construct it using the DOM APIs."
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎÎ, ÏÎ ÏÏÏÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎ ÎÎÏÏÎÎÎ ÎÎÎÏÎÏÏÎÎÎÏ, ÎÎÎÎ ÏÏÎ ÏÎÎÏ "
+"ÏÎÎÏÏÎ. ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÏÏÎÏÎÎÎÏÎÏÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÎÎÎÏÎÎÏÎÏ ÎÎ CSS, ÎÏÎÎ ÏÏÏÏ "
+"ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎ ÎÎÎÎ ÏÎÎÎÎÎ HTML. ÎÏÎÏÏÎÏÎ ÏÎÎÎÎÎ ÏÏÏÏÎÎ ÏÎÏ ÎÎ ÎÏÎÏÎÏÏÎÏÎ "
+"ÎÎ ÏÏÎÏÎÏÏÎÏÎÏÎ ÎÎÏÎÎÎ CSS ÏÏÎ ÏÎÎÎÎÎ: ÎÏÎÏÎÎÏÎ ÎÎ ÏÎ ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ ÎÏÏÎÎÏ "
+"ÎÎÎÏÎÏÎ HTML. ÎÎ ÎÏÎÏÎÏÏÎÏÎ ÎÎ ÏÎ ÎÎÏÏÎÎÏÏÏÎÏÎ ÏÏÎ ÎÎÏÏÎÏÎÎ "
+"<code>style</code> ÏÏÎ ÏÏÎÎÏÎÎÏÎ <code>div</code>. ÎÎ ÎÏÎÏÎÏÏÎÏÎ ÎÎÏÎÎ ÎÎ ÏÎ "
+"ÎÎÏÎÏÎÎÏÎÏÎÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÏÎÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ APIs DOM."
+
+#: C/message-board.c.page:294(p)
+msgid ""
+"In this tutorial, you'll attach the CSS using the <code>user-stylesheet-uri</"
+"code> property of the <code>WebKitWebSetting</code> object attached to your "
+"web view. In a more complete application, you would want to save and load "
+"your HTML file. Keeping the style information outside the actual HTML means "
+"that you can change the styling completely within your application, without "
+"having to change users' files. You would normally just install a file along "
+"with your application, but just to keep everything in one file for this "
+"demo, we'll use a trick called a data URI. First, define the CSS as a static "
+"string near the top of your file."
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ, ÎÎ ÎÏÎÏÏÎÎÏÎÏÎ ÏÎ CSS ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ ÎÎÎÏÏÎÏÎ <code"
+">user-stylesheet-uri</code> ÏÎÏ ÏÏÎÏÎÏÏÎÎÎÎÎÏ ÎÎÏÎÎÎÎÎÎÎÎÏ "
+"<code>WebKitWebSetting</code> ÏÏÎÎ ÏÏÎÎÎÎÎ ÏÎÏ ÎÏÏÎÏ. ÎÎ ÎÎÎ ÏÎÎ ÏÎÎÏÎ "
+"ÎÏÎÏÎÎÎÎ, ÎÎ ÎÎÎÎÏÎ ÎÎ ÎÏÎÎÎÎÎÏÏÎÏÎ ÎÎÎ ÎÎ ÏÎÏÏÏÏÎÏÎ ÏÎ ÎÏÏÎÎÎ HTML. "
+"ÎÎÎÏÎÏÏÎÏÎÏ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÎÎÏÏÎÏÎÎÎÏÎÏ ÎÎÏ ÎÏÏ ÏÎ ÎÎÎÏÎÏ HTML ÏÎÎÎÎÎÎÎ ÏÏÎ "
+"ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎÎÎÏÎ ÎÎÏÏÎÎÎ ÏÎ ÎÎÏÏÎÏÎÎÎÏÎ ÎÎÏ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ, ÏÏÏÎÏ ÎÎ "
+"ÏÏÎÎÎÏÏÎÎ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎ ÎÏÏÎÎÎ ÏÏÎÏÏÎ. ÎÎÎÎÎÎÎÎ ÎÎ ÎÎÎÎÏÎÏÏÎÏÎÏÎ ÎÏÎÎ ÎÎÎ "
+"ÎÏÏÎÎÎ ÎÎÎÎ ÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ, ÎÎÎÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÏÎÏÎ ÎÏÎÎ ÎÎÎÎ ÏÎ ÏÎ ÎÎÎ "
+"ÎÏÏÎÎÎ ÎÎÎ ÎÏÏÎ ÏÎÎ ÏÎÏÎÏÏÎÎÏÎ, ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÎÏÎÏÎ ÏÎÏ ÎÎÎÎÏÎÎ "
+"ÎÎÎÎÎÎÎÎ URI. ÎÏÏÏÎ, ÎÏÎÏÏÎ ÏÎ CSS ÏÏ ÏÏÎÏÎÎÎ ÏÏÎÎÎÎÎÏÎÎÏÎ ÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÏÎ "
+"ÏÎÏ ÎÏÏÎÎÎÏ ÏÎÏ."
+
+#: C/message-board.c.page:316(p)
+msgid ""
+"All you have in this example are <code>div</code> elements inside a "
+"<code>body</code> element. If you created more complicated HTML, you could "
+"use whatever CSS is necessary. In fact, if you're comfortable with CSS, you "
+"should trying changing this to something you like better."
+msgstr ""
+"Î,ÏÎ ÎÏÎÏÎ ÏÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÎÎÎÎÎ ÏÏÎÎÏÎÎÎ <code>div</code> ÎÎÏÎ ÏÎ ÎÎÎ "
+"ÏÏÎÎÏÎÎÎ <code>body</code>. ÎÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎ HTML, ÎÎ "
+"ÎÏÎÏÎÏÏÎÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÏÎÎÎÎÎÏÎÏÎ CSS ÎÎÎÎÎ ÎÏÎÏÎÎÏÎÏÎ. ÎÏÎÎ "
+"ÏÏÎÎÎÎÏÎÎÏÏÎÏÎ, ÎÎÎ ÎÎÏÎÏÏÎ ÎÎÎÏÎ ÎÎ CSS, ÎÎ ÏÏÎÏÎÎ ÎÎ ÏÏÎÏÏÎÎÎÏÎÏÎ ÎÎ ÏÎ "
+"ÎÎÎÎÎÎÏÎ ÎÎ ÎÎÏÎ ÏÎÏ ÏÎÏ ÎÏÎÏÎÎ ÎÎÎÏÏÎÏÎ."
+
+#: C/message-board.c.page:321(p)
+msgid ""
+"To apply the CSS, you set the <code>user-stylesheet-uri</code> in the "
+"<code>create_window</code> function, anywhere after <code>view</code> has "
+"already been defined."
+msgstr ""
+"ÎÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ CSS, ÎÏÎÎÎÏÎ ÏÎÎ <code>user-stylesheet-uri</code> ÏÏÎÎ "
+"ÏÏÎÎÏÏÎÏÎ <code>create_window</code>, ÎÏÎÏÎÎÏÎÏÎ ÎÎÏÎ ÏÎÎ ÎÏÎÏÎÏ ÏÎÏ "
+"<code>view</code>."
+
+#: C/message-board.c.page:325(p)
+msgid "g_base64_encode has bad args"
+msgstr "ÎÎ g_base64_encode ÎÏÎÎ ÎÏÏÎÎÎ ÎÏÎÏÎÎÏÎ"
+
+#: C/message-board.c.page:337(p)
+msgid ""
+"Also, make sure to add variable declarations for <code>tmp</code> and "
+"<code>css</code> to the top of <code>create_window</code>."
+msgstr ""
+"ÎÏÎÏÎÏ, ÎÎÎÎÎÏÎÎÎÏÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÎÎÎÏÏÎÎÏ ÎÎÏÎÎÎÎÏÎÏ ÎÎÎ <code>tmp</code> "
+"ÎÎÎ <code>css</code> ÏÏÎÎ ÎÎÏÏÏÎ ÏÎÏ <code>create_window</code>."
+
+#: C/message-board.c.page:340(code)
+#, no-wrap
+msgid ""
+"\n"
+"gchar *tmp, *css;\n"
+msgstr ""
+"\n"
+"gchar *tmp, *cssÂ\n"
+
+#: C/message-board.c.page:344(p)
+msgid ""
+"A data URI starts with <sys>data:</sys> and some information about the "
+"content type and how the data is encoded. The actual data follows after a "
+"comma, in this case encoded in Base64. Unlike other URI schemes like "
+"<sys>http:</sys>, <sys>ftp:</sys>, and <sys>file:</sys>, the <sys>data:</"
+"sys> URI scheme doesn't specify where to find a file to load. Rather, it "
+"gives the entire contents of the file."
+msgstr ""
+"ÎÎÎÎÎÎÎÎ URI ÎÎÎÎÎÎÏÎ ÎÎ <sys>data:</sys> ÎÎÎ ÎÎÏÎÎÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÎÎÎ ÏÎÎ "
+"ÏÏÏÎ ÏÎÏÎÎÏÎÎÎÎÎÏ ÎÎÎ ÏÎÎ ÎÏÎÎÎÎÏÎÎÎÏÎ ÎÎÎÎÎÎÎÏÎ. ÎÎ ÎÎÎÏÎÎ ÎÎÎÎÎÎÎÎ "
+"ÎÎÎÎÎÏÎÎÏÎ ÎÎÏÎ ÏÎ ÎÏÎÎÎ, ÏÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÏÎÎÎÎÏÎÎÎÎÎÎÎ ÏÎ Base64. "
+"ÎÎÏÎÎÎÏÎ ÎÎ ÎÎÎÎ ÏÏÎÎÎÏÎ URI ÏÏÏÏ <sys>http:</sys>, <sys>ftp:</sys> ÎÎÎ "
+"<sys>file:</sys>, ÏÎ ÏÏÎÎÎ <sys>data:</sys> URI ÎÎÎ ÎÎÎÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÎÎÏÎ "
+"ÎÎÎ ÎÏÏÎÎÎ ÎÎÎ ÏÏÏÏÏÏÎ. ÎÎÎÎÎÎ, ÎÎÎÎÎ ÏÎ ÏÏÎÎÎÎÎÎ ÏÎÏÎÎÏÏÎÎÎÎ ÏÎÏ ÎÏÏÎÎÎÏ."
+
+#: C/message-board.c.page:351(p)
+msgid ""
+"The code above first encodes your CSS definitions in Base64, then combines "
+"that with a fixed string to create a data URI. The <code>g_strconcat</code> "
+"function can take any number of string arguments and concatenate them all "
+"together, so you have to pass <code>NULL</code> as the final argument so it "
+"knows when to stop. And don't forget to free those temporary strings after "
+"you set the stylesheet property."
+msgstr ""
+"Î ÏÎÏÎÏÎÎÏ ÎÏÎÎÎÎÏ ÏÏÏÏÎ ÎÏÎÎÎÎÏÎÎÎÎ ÏÎÏÏ ÎÏÎÏÎÎÏÏ ÏÎÏ CSS ÏÎ Base64, ÎÏÎÎÏÎ "
+"ÏÏÎÎÏÎÎÎÎ ÎÏÏÏ ÎÎ ÏÏÎÎÎÏÎ ÏÏÎÎÎÎÎÏÎÎÏÎ ÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎÎÎÎÎÏÎ URI. Î "
+"ÏÏÎÎÏÏÎÏÎ <code>g_strconcat</code> ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎ ÎÏÎÎÎÎÎÏÎÏÎ ÎÏÎÎÎÏ "
+"ÎÏÎÏÎÎÏÏÎ ÏÏÎÎÎÎÎÏÎÎÏÎÏ ÎÎÎ ÎÎ ÏÎ ÏÏÎÎÎÏÏÎÎ ÏÎÎ ÎÎÎÎ, ÎÏÏÎ ÎÏÎÏÎ ÎÎ ÏÎÏÎÏÎÏÎ "
+"ÏÎ <code>NULL</code> ÏÏ ÏÎÎÎÎÏ ÏÏÎÏÎÎ ÎÎÎ ÎÎ ÎÎÏÏÎÎÎÎ ÏÏÏÎ ÎÎ ÏÏÎÎÎÏÎÏÎÎ. "
+"ÎÎÎ ÎÎÏÎÏÎÏÎ ÎÎ ÎÎÎÏÎÎÏÏÏÎÏÎ ÎÏÏÎÏ ÏÎÏ ÏÏÎÏÏÏÎÎÎÏ ÏÏÎÎÎÎÎÏÎÎÏÎÏ ÎÏÎÏ ÎÏÎÏÎÏÎ "
+"ÏÎÎ ÎÎÎÏÏÎÏÎ ÏÏÎÎÎ ÎÎÏÏÎÏÎÎÎÏÎÏ."
+
+#: C/message-board.c.page:358(p)
+msgid ""
+"Build and run the program again. It should now work exactly the same as at "
+"the end of the last section, except the messages will be nicely styled with "
+"a border and a subtle background gradient."
+msgstr ""
+"ÎÎÏÎÏÎÎÏÎ ÎÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏ ÏÎÎÎ. ÎÎ ÏÏÎÏÎÎ ÏÏÏÎ ÎÎ ÎÎÏÎÎÏÎÎ "
+"ÎÎÏÎÎÏÏ ÏÎ ÎÎÎÎ ÏÏÏÏ ÏÏÎ ÏÎÎÎÏ ÏÎÏ ÏÎÎÎÏÏÎÎÎÏ ÎÎÏÏÎÏÎÏ, ÎÎÏÏÏ ÎÏÏ ÏÎ "
+"ÎÎÎÏÎÎÏÎ ÏÎÏ ÎÎ ÎÎÏÏÎÏÎÎÎÏÎÏÎÎ ÏÎÎÏÏÎ ÎÎ ÏÎÏÎÎÏÎÎÎÎ ÎÎÎ ÎÎÏÏÎ ÎÎÎÎÎÎÎÎÏÎ "
+"ÏÎÏÎÏÎÎÎÎÎÏ."
+
+#: C/message-board.c.page:364(title)
+msgid "Learn more"
+msgstr "ÎÎÎÎÏÎ ÏÎÏÎÏÏÏÏÎÏÎ"
+
+#: C/message-board.c.page:366(p)
+msgid ""
+"This tutorial showed you how to create a basic application using GTK+ and "
+"WebKit, including showing a document and manipulating its contents. To "
+"create a real application, you probably want to do a little bit more. Try "
+"adding features on your own. Here are a few ideas:"
+msgstr ""
+"ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ ÎÎÎÏÎÎÎ ÏÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎÏ ÎÎÏÎÎÎÏ ÎÏÎÏÎÎÎÎÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ "
+"GTK+ ÎÎÎ WebKit, ÏÎÏÎÎÎÎÎÎÎÎÎÏÎÏ ÏÎÎ ÎÎÏÎÎÎÏÎ ÎÎÏÏ ÎÎÎÏÎÏÎÏ ÎÎÎ ÎÏÎÎÎÏÎÎÏÎÎ "
+"ÏÏÎ ÎÎÎÎÎÎÎÏÎ ÏÎÏ. ÎÎÎ ÏÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎÏ ÏÏÎÎÎÎÏÎÎÎÏ ÎÏÎÏÎÎÎÎÏ, ÎÎ ÎÎÎÎÏÎ "
+"ÏÏÎÏÎÎÏÏ ÎÎ ÎÎÎÎÏÎ ÎÎÏÎ ÏÎÏÎÏÏÏÏÎÏÎ. ÎÏÎÏÏÎÎÎÏÏÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÎÎÎÎ ÏÎÏ "
+"ÏÎÏÎÎÏÎÏÎÏÏÎÎÎ. ÎÎ ÎÎÏÎÎÎÏ ÎÎÎÎÏ:"
+
+#: C/message-board.c.page:372(p)
+msgid ""
+"If you're comfortable with CSS, try changing the style of the message "
+"display. CSS is easy to get started with, but increasingly more powerful. "
+"There is a wealth of CSS tutorials on the Internet, and just about "
+"everything you can do on the web, you can do in this application."
+msgstr ""
+"ÎÎÎ ÎÎÏÎÏÏÎ ÎÎÎÏÎÎ ÎÎ ÏÎ CSS, ÎÎÎÎÎÎÏÏÎ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎ ÎÎÏÏÎÏÎÎÎÏÎ ÏÎÏ "
+"ÎÎÏÎÎÎÏÎÏ ÏÎÏ ÎÎÎÏÎÎÏÎÏ. ÎÎ CSS ÎÎÎÎÎ ÎÏÎÎÎÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎÏÎ, ÎÎÎÎ ÎÎÎÏÎÏÏ "
+"ÏÎÏÎÏÏÏÏÎÏÎ ÎÏÏÏÏÏ. ÎÏÎÏÏÎÎ ÏÎÎÎÎÏ ÎÎÎÎÎÎÏÏÎ CSS ÏÏÎ ÎÎÎÎÎÎÏÏÎ ÎÎÎ ÏÏÎÎÏÎ "
+"ÎÎÎÎ ÏÎ ÏÎÏ ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎÏÎ ÏÏÎÎ ÎÏÏÏ, ÎÏÎÏÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÎ ÎÏÏÎÎ ÏÎÎ "
+"ÎÏÎÏÎÎÎÎ."
+
+#: C/message-board.c.page:378(p)
+msgid ""
+"Right now, you lose all your messages whenever you close the message board. "
+"Try saving the HTML contents after each post, and loading the saved file (if "
+"it exists) on startup."
+msgstr ""
+"ÎÏÏÎ ÎÎÎÏÏÏ, ÏÎÎÎÏÎ ÏÎÎ ÏÎ ÎÎÎÏÎÎÏÎ ÏÎÏ ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÏÎÎ ÏÎÎÎÎÎ ÎÎÎÏÎÎÏÏÎ. "
+"ÎÎÎÎÎÎÏÏÎ ÎÎ ÎÏÎÎÎÎÎÏÏÎÏÎ ÏÎ ÏÎÏÎÎÏÏÎÎÎÎ HTML ÎÎÏÎ ÎÏÏ ÎÎÎÎ ÏÎÏÏÎÏÏÎÎÏÎ ÎÎÎ "
+"ÏÎÏÏÏÏÏÎ ÏÎ ÎÏÎÎÎÎÎÏÎÎÎÎ ÎÏÏÎÎÎ (ÎÎÎ ÏÏÎÏÏÎÎ) ÏÏÎÎ ÎÎÎÎÎÎÏÎ."
+
+#: C/message-board.c.page:382(p)
+msgid "Link to method to get HTML from DOM and to GIO APIs."
+msgstr "ÎÏÎÎÎÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÎ ÎÎÏÎÏ HTML ÎÏÏ DOM ÎÎÎ ÏÎ GIO APIs."
+
+#: C/message-board.c.page:386(p)
+msgid ""
+"If you keep your messages around for a long time, you'll start wondering "
+"when you posted them. Add a timestamp to each message when it's posted. "
+"You'll probably want to create some additional child <code>div</code> "
+"elements with different classes that you can style in the CSS."
+msgstr ""
+"ÎÎ ÎÏÎÏÎÏÎ ÏÎ ÎÎÎÏÎÎÏÎ ÏÎÏ ÎÎÎ ÏÎÎÏ ÏÏÏÎÎ, ÎÎ ÎÏÏÎÏÎÏÎ ÎÎ ÎÎÎÏÏÏÎÏÏÎ ÏÏÏÎ ÏÎ "
+"ÏÎÏÏÎÏÎÎÎÏÎÏÎ. ÎÏÎÏÎÎÏÎÏÎ ÎÎÎ ÏÎÎÎÎÎ ÏÏÏÎÎÏ ÏÎ ÎÎÎÎ ÎÎÎÏÎÎ ÏÏÎÎ "
+"ÏÎÏÏÎÏÎÎÎÎÏÎÎ. ÎÎ ÎÎÎÎÏÎ ÏÏÎÏÎÎÏÏ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÏÎÎÎ ÏÏÏÏÎÎÏÎ ÎÎÏÎÏÎÏÎ "
+"ÏÏÎÎÏÎÎÎ <code>div</code> ÎÎ ÎÎÎÏÎÏÎÏÎÎÎÏ ÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÏÎÎÏÎ ÎÎ "
+"ÎÎÏÏÎÏÎÎÎÏÎÏÎ ÏÎ CSS."
+
+#: C/message-board.c.page:390(p)
+msgid "Link to strftime or something"
+msgstr "ÎÏÎÎÎÏÎ ÎÎ strftime Î ÎÎÏÎ ÎÎÎÎ"
+
+#: C/message-board.c.page:393(p)
+msgid ""
+"This program keeps messages around forever. Think about ways you could allow "
+"the user to delete messages. Perhaps you want messages to disappear "
+"automatically after they're too old, or after there are a certain number of "
+"messages before them. Or you could add a link in each message to delete it. "
+"You could even override the context menu when you right-click on a message. "
+"These features involve exploring WebKit's DOM API more."
+msgstr ""
+"ÎÏÏÏ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÏÎÏÎ ÏÎ ÎÎÎÏÎÎÏÎ ÎÎÎ ÏÎÎÏÎ. ÎÎÎÏÏÎÎÏÎ ÏÏÏÏÎÏÏ ÏÎÏ ÎÎ "
+"ÎÏÎÏÎÏÏÎÎ ÎÎ ÎÏÎÏÏÎÏÎÏÎ ÏÏÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎÏÎÏÎÎ ÎÎÎÏÎÎÏÎ. ÎÏÏÏ ÎÎÎÎÏÎ ÏÎ "
+"ÎÎÎÏÎÎÏÎ ÎÎ ÎÎÎÏÎÎÎÎÎÎÏÎÎ ÎÏÏÏÎÎÏÎ ÏÏÎÎ ÏÎÎÎÏÎÎÏÎ, Î ÏÏÎÎ ÏÏÎÏÏÎÎ ÎÎÎÏ "
+"ÏÏÎÎÎÎÏÎÎÎÎÎÏ ÎÏÎÎÎÏÏ ÎÎÎÏÎÎÏÏÎ ÏÏÎÎ ÎÏÏ ÎÏÏÎ. Î ÎÎ ÎÏÎÏÎÏÏÎÏÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ "
+"ÎÎÎÎ ÏÏÎÎÎÏÎÎ ÏÎ ÎÎÎÎ ÎÎÎÏÎÎ ÎÎÎ ÎÎÎÎÏÎÏÎ ÏÎÏ. ÎÎ ÎÏÎÏÎÏÏÎÏÎ ÎÎÏÎÎ ÎÎ "
+"ÎÎÏÎÎÎÏÎÏÏÎÏÎÏÎ ÏÎ ÎÎÎÎÏ ÏÎÏÎÎÏÎÎÎÎÎÏ ÏÏÎÎ ÎÎÎÎÏÎ ÎÎÎÎÏ ÎÎÎÎ ÏÎ ÎÎÎÏÎÎ. "
+"ÎÏÏÎÏ ÏÎ ÏÎÏÎÎÏÎÏÎÏÏÎÎÎ ÏÎÏÎÎÏÎÏÎ ÏÎÏÎÏÏÏÏÎÏÎ ÏÎÏÎÎÎÎÏÎ ÏÎÏ DOM API ÏÎÏ "
+"WebKit."
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/magic-mirror.vala.page:40(None)
+msgid "@@image: 'media/magic-mirror.png'; md5=8171faea6ed3b6ddac0da084c29e4e22"
+msgstr "@@image: 'media/magic-mirror.png'Â md5=8171faea6ed3b6ddac0da084c29e4e22"
+
+#: C/magic-mirror.vala.page:9(desc)
+msgid "Use your webcam as a mirror using the GStreamer framework and Gtk+"
+msgstr ""
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ ÎÎÎÎÏÎ ÏÎÏ ÏÏ ÎÎÎÏÎÏÏÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ ÏÎÎÎÎÏÏ "
+"GStreamer ÎÎÎ Gtk+"
+
+#: C/magic-mirror.vala.page:13(name)
+msgid "Daniel G. Siegel"
+msgstr "Daniel G. Siegel"
+
+#: C/magic-mirror.vala.page:14(email)
+#| msgid "jwendell gnome org"
+msgid "dgsiegel gnome org"
+msgstr "dgsiegel gnome org"
+
+#: C/magic-mirror.vala.page:22(title)
+msgid "4 Magic Mirror"
+msgstr "4 ÎÎÎÎÎÏÏ ÎÎÎÏÎÏÏÎÏ"
+
+#: C/magic-mirror.vala.page:25(em)
+msgid ""
+"Your mirror just fell off the wall and broke into a thousand pieces â but "
+"you need a mirror to shave your beard off or add some makeup! You only have "
+"15 minutes left before catching the bus to work. So what can you do?"
+msgstr ""
+"Î ÎÎÎÏÎÏÏÎÏ ÏÎÏ ÎÏÎÎÏ ÎÏÎÏÎ ÎÏÏ ÏÎÎ ÏÎÎÏÎ ÎÎÎ ÎÏÏÎÏÎ ÏÎ ÏÎÎÎÎ ÎÎÎÎÎÏÎÎ - "
+"ÎÎÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÎÎÏ ÎÎÎÏÎÏÏÎÏ ÎÎ ÎÏÏÎÏÎÏÎ ÏÎ ÎÎÎÎÎÎÎÎ ÏÎÏ ÎÎÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ "
+"ÎÎÏÎÎÎ ÎÎÎÎÏÎÏÎÎÎ! ÎÎÏ ÎÏÎÎÎÎÎÏÎ 15 ÎÎÏÏÎ ÏÏÎÎ ÎÎ ÏÏÎÎÎÎÎÏÎ ÏÎ ÎÎÏÏÎÏÎÎÎ "
+"ÎÎÎ ÏÎ ÎÎÏÎÎÎÎ. ÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎÏÎ;"
+
+#: C/magic-mirror.vala.page:26(p)
+#| 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:"
+msgid ""
+"In this tutorial, we're going to make a program which lets you use your "
+"webcam as a mirror. You will learn how to:"
+msgstr ""
+"ÎÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ, ÎÎ ÏÏÎÎÎÎÏÎÎ ÎÎÎ ÏÏÏÎÏÎÎÎÎ ÏÎÏ ÎÏÎÏÏÎÏÎÎ ÏÎ ÏÏÎÏÎ ÏÎÏ "
+"ÎÏÏÎÎÎÎÎÏÎÏ ÏÎÏ ÏÏ ÎÎÎÏÎÏÏÎ. ÎÎ ÎÎÎÎÏÎ ÏÏÏ ÎÎ:"
+
+#: C/magic-mirror.vala.page:28(p)
+#| msgid "A first Gtk application"
+msgid "Create a GTK+ application"
+msgstr "ÎÎÎÎÎÏÏÎÎÎ ÎÏÎÏÎÎÎÎÏ ÏÎ GTK+"
+
+#: C/magic-mirror.vala.page:29(p)
+msgid "Access your webcam using GStreamer and embed the result into a window"
+msgstr ""
+"ÎÏÏÏÎÎÏÎ ÏÎÏ ÎÏÏÎÎÎÎÎÏÎ ÏÎÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ GStreamer ÎÎÎ ÎÎÏÏÎÎÏÏÏÎ ÏÎÏ "
+"ÎÏÎÏÎÎÎÏÎÎÏÎÏ ÏÎ ÏÎÏÎÎÏÏÎ"
+
+#: C/magic-mirror.vala.page:30(p)
+msgid "Grab photos off your webcam"
+msgstr "ÎÎÏÎ ÏÏÏÎÎÏÎÏÎÏÎ ÏÎÏ ÎÏÏÎÎÎÎÎÏÎÏ ÏÎÏ"
+
+#: C/magic-mirror.vala.page:32(p) C/image-viewer.vala.page:39(p)
+#: C/image-viewer.py.page:34(p) C/image-viewer.js.page:34(p)
+#: C/guitar-tuner.vala.page:35(p) C/guitar-tuner.py.page:31(p)
+#: C/guitar-tuner.cpp.page:30(p) C/guitar-tuner.c.page:31(p)
+msgid "You'll need the following to be able to follow this tutorial:"
+msgstr ""
+"ÎÎ ÏÏÎÎÎÏÏÎÎÏÎ ÏÎ ÏÎÏÎÎÎÏÏ ÎÎÎ ÎÎ ÎÏÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÎÏÎÎÏÎÏÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ:"
+
+#: C/magic-mirror.vala.page:34(p) C/image-viewer.py.page:36(p)
+#: C/image-viewer.js.page:36(p) C/guitar-tuner.py.page:33(p)
+#: C/guitar-tuner.cpp.page:32(p) C/guitar-tuner.c.page:33(p)
+msgid "An installed copy of the <link xref=\"getting-ready\">Anjuta IDE</link>"
+msgstr ""
+"ÎÎÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÎÎÏÎÎÏÎÏÎ ÏÎÏ <link xref=\"getting-ready\">Anjuta IDE</link>"
+
+#: C/magic-mirror.vala.page:35(p)
+msgid "Installed copies of GTK, GStreamer, and a Vala compiler"
+msgstr "ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÎÎÏÎÎÏÎÏÎ ÏÎÏ GTK, GStreamer ÎÎÎ ÎÎÎ ÎÎÏÎÎÎÏÏÏÎÏÏÎ Vala"
+
+#: C/magic-mirror.vala.page:36(p)
+#| msgid "Basic knowledge of the python programming language"
+msgid "Basic knowledge of an object-oriented programming language"
+msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÎÎÎÏ ÎÎÏÎÎÎÎÎÎÎÎÏÏÏÎÏÎÏÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ"
+
+#: C/magic-mirror.vala.page:50(p)
+#| 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."
+msgid ""
+"Choose <gui>Gtk+ (simple)</gui> from the <gui>Vala</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>Gtk+ (ÎÏÎÏ)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>Vala</gui>, ÎÎÎÎ "
+"<gui>ÎÏÏÎÏÏÎ</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ ÎÎÎÎÏ "
+"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÎÎÏÎÎÏÎÎÏ ÏÎ <file"
+">guitar-tuner</file>."
+
+#: C/magic-mirror.vala.page:53(p)
+#| 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>."
+msgid ""
+"Disable <gui>Use GtkBuilder for user interface</gui> as we will create the "
+"UI manually in this tutorial. Check the <link xref=\"guitar-tuner.vala"
+"\">Guitar-Tuner</link> tutorial using the interface builder."
+msgstr ""
+"ÎÏÎÎÎÏÎÎÏÎÎÎÏÏÎ ÏÎ <gui>ÎÏÎÏÎ ÏÎÏ GtkBuilder ÎÎÎ ÎÎÎÏÎÏÎ ÏÏÎÏÎ</gui> ÎÏÎÎÎÎ "
+"ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÏÎÎÏÎÎÎÎÎÏÎ ÏÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ. ÎÎÎÎÎÏÏÏÎ "
+"ÏÎ ÎÎÎÎÎÎ <link xref=\"guitar-tuner.vala\">ÏÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ</link> "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ ÎÎÏÎÏÎÎÏÎÏÏÎ ÎÎÎÏÎÏÎÏ."
+
+#: C/magic-mirror.vala.page:58(p)
+msgid ""
+"Make sure that <gui>Configure external packages</gui> is selected. On the "
+"next page, select <em>gstreamer-0.10</em> from the list to include the "
+"<app>GStreamer</app> library into your project."
+msgstr ""
+"ÎÎÎÎÎÏÎÎÎÏÎ ÏÏÎ ÏÎ <gui>ÏÏÎÎÎÏÎ ÎÎÏÏÎÏÎÎÏÎ ÏÎÎÎÏÏÎ</gui> ÎÏÎÎÎÏÏÎÎÎ. ÎÏÎÎ "
+"ÎÏÏÎÎÎÎ ÏÎÎÎÎÎ, ÎÏÎÎÎÎÏÎ <em>gstreamer-0.10</em> ÎÏÏ ÏÎ ÎÎÏÏÎ ÎÎÎ "
+"ÏÏÎÏÎÏÎÎÎÏÎ ÏÎÏ ÎÎÎÎÎÎÎÎÎÎÏ <app>GStreamer</app> ÏÏÎ ÎÏÎÎ ÏÎÏ."
+
+#: C/magic-mirror.vala.page:62(p)
+#| 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:"
+msgid ""
+"Click <gui>Apply</gui> and the project will be created for you. Open "
+"<file>src/magic_mirror.vala</file> from the <gui>Project</gui> or <gui>File</"
+"gui> tabs. You should see some code which starts with the lines:"
+msgstr ""
+"ÎÎÏÎÏÏÎ <gui>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ. ÎÎÎÎÎÏÎ "
+"<file>src/magic_mirror.vala</file> ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ <gui>ÎÏÎÎ</gui> Î "
+"<gui>ÎÏÏÎÎÎ</gui>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÎÏÎÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎ ÎÎ ÏÎÏ "
+"ÎÏÎÎÎÎÏ:"
+
+#: C/magic-mirror.vala.page:71(title) C/image-viewer.vala.page:106(title)
+#: C/image-viewer.cpp.page:60(title) C/image-viewer.c.page:59(title)
+#: C/guitar-tuner.vala.page:68(title) C/guitar-tuner.cpp.page:63(title)
+#: C/guitar-tuner.c.page:64(title)
+#| msgid "Run the code for the first time"
+msgid "Build the code for the first time"
+msgstr "ÎÎÏÎÏÎÎÏÎÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÎÎÎ ÏÏÏÏÎ ÏÎÏÎ"
+
+#: C/magic-mirror.vala.page:72(p)
+#| 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:"
+msgid ""
+"The code loads an (empty) window and shows it. More details are given below; "
+"skip this list if you understand the basics:"
+msgstr ""
+"Î ÎÏÎÎÎÎÏ ÏÎÏÏÏÎÎÎ ÎÎÎ (ÎÎÎÏ) ÏÎÏÎÎÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÎÎÎÎÎ. ÎÎÏÎÏÏÏÏÎÏÎÏ "
+"ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏÏÎÏÎ ÏÎÎ ÎÎÏÏÂ ÏÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎ ÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎ "
+"ÎÎÏÎÎÎ:"
+
+#: C/magic-mirror.vala.page:75(p) C/guitar-tuner.vala.page:73(p)
+msgid ""
+"The two <code>using</code> lines import namespaces so we don't have to name "
+"them explicitly."
+msgstr ""
+"ÎÎ ÎÏÎ ÎÏÎÎÎÎÏ <code>using</code> ÎÎÏÎÎÎÏÎ ÏÏÏÎÏÏ ÎÎÎÎÎÏÏÎ ÎÏÏÎ ÏÏÏÎ ÎÎ ÎÎÎ "
+"ÏÎÏÏ ÎÎÎÎÎÏÎÏÎÎ ÏÎÏÎ."
+
+#: C/magic-mirror.vala.page:78(p)
+#| 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."
+msgid ""
+"The constructor of the <code>Main</code> class creates a new window and sets "
+"its title. Afterwards the window is shown and a signal is connected which "
+"quits the application if the window is closed. More on signals later on."
+msgstr ""
+"Î ÎÎÏÎÏÎÎÏÎÏÏÎÏ ÏÎÏ ÎÎÎÏÎÏ <code>Main</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÎ ÏÎÏÎÎÏÏÎ ÎÎÎ "
+"ÎÏÎÎÎÎ ÏÎÎ ÏÎÏÎÎ ÏÎÏ. ÎÎÏÏÏÎÎ ÎÎÏÎÎÎÎÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎ ÎÎÎ ÏÎÎÎ "
+"ÏÏÎÎÎÎÏÎÎ ÏÎÏ ÎÎÎÎÏÎÎÎÎÏÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ, ÎÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÏÎÎ. "
+"ÎÎÏÎÏÏÏÏÎÏÎ ÎÎÎ ÏÎ ÏÎÎÎÏÎ ÎÏÎÏÏÎÏÎ."
+
+#: C/magic-mirror.vala.page:82(p)
+msgid ""
+"The static <code>main</code> function is run by default when you start a "
+"Vala application. It calls a few functions which create the Main class, set "
+"up and then run the application. The <code>Gtk.Main</code> function starts "
+"the GTK main loop, which runs the user interface and starts listening for "
+"events (like clicks and key presses)."
+msgstr ""
+"Î ÏÏÎÏÎÎÎ ÏÏÎÎÏÏÎÏÎ <code>main</code> ÏÏÎÏÎÎ ÎÏÏ ÏÏÎÎÏÎÎÎÎÎ ÏÏÎÎ ÎÎÎÎÎÎÏÎ "
+"ÎÎÎ ÎÏÎÏÎÎÎÎ Vala. ÎÎÎÎÎ ÎÎÎÎÏ ÏÏÎÎÏÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎÎ ÎÏÏÎÎ ÎÎÎÏÎ, "
+"ÏÏÎÎÎÎÎÏÎ ÎÎÎ ÎÏÎÎÏÎ ÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ. Î ÏÏÎÎÏÏÎÏÎ "
+"<code>Gtk.Main</code> ÎÎÎÎÎÎ ÏÎÎ ÎÏÏÎÎ ÎÏÏÏÎ ÏÎÏ GTK, ÏÎÏ ÎÎÏÎÎÎÎ ÏÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎÏÏÎ ÎÎÎ ÎÎÎÎÎÎ ÏÎÎ ÎÎÏÏÎÏÎ ÎÎÎ ÏÏÎÎÎÎÏÎ (ÏÏÏÏ ÎÎÎÎ ÎÎÎ ÏÎÏÎÎÎÏÎ "
+"ÏÎÎÎÏÏÎÏ)."
+
+#: C/magic-mirror.vala.page:86(p) C/image-viewer.vala.page:126(p)
+#: C/image-viewer.cpp.page:76(p) C/image-viewer.c.page:78(p)
+#: C/guitar-tuner.cpp.page:78(p) C/guitar-tuner.c.page:83(p)
+#| msgid ""
+#| "This code is ready to be used, so you can run it by clicking "
+#| "<guiseq><gui>Run</gui><gui>Execute</gui></guiseq>."
+msgid ""
+"This code is ready to be used, so you can compile it by clicking "
+"<guiseq><gui>Build</gui><gui>Build Project</gui></guiseq> (or press "
+"<keyseq><key>Shift</key><key>F7</key></keyseq>)."
+msgstr ""
+"ÎÏÏÏÏ Î ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ, ÎÏÏÏÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÎ "
+"ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÎÎ ÎÎÎÎ <guiseq><gui>ÎÎÏÎÏÎÎÏÎ</gui><gui>ÎÎÏÎÏÎÎÏÎ "
+"ÎÏÎÎÏ</gui></guiseq> (Î ÏÎÎÎÎÎÏÎÏ "
+"<keyseq><key>Shift</key><key>F7</key></keyseq>)."
+
+#: C/magic-mirror.vala.page:87(p) C/image-viewer.vala.page:127(p)
+msgid ""
+"Change the <gui>Configuration</gui> to <gui>Default</gui> and then press "
+"<gui>Execute</gui> to configure the build directory. You only need to do "
+"this once, for the first build."
+msgstr ""
+"ÎÎÎÎÎÎ ÏÎÏ <gui>ÏÏÎÎÎÏÎÏ</gui> ÏÎ <gui>ÏÏÎÎÏÎÎÎÎÎ</gui> ÎÎÎ ÏÏÏÎ ÏÎÏÎÎÎ "
+"<gui>ÎÎÏÎÎÎÏÎ</gui> ÎÎÎ ÏÏÎÎÎÏÎ ÏÎÏ ÎÎÏÎÎÏÎÎÏ ÎÎÏÎÏÎÎÏÎÏ. ÎÏÎÎÎÎÎÏÎÎ ÎÎ ÏÎ "
+"ÎÎÎÎÏÎ ÎÏÎÎ ÎÎÎ ÏÎÏÎ, ÎÎÎ ÏÎÎ ÏÏÏÏÎ ÎÎÏÎÏÎÎÏÎ."
+
+#: C/magic-mirror.vala.page:91(title)
+msgid "Access the webcam video stream with GStreamer"
+msgstr "ÎÏÏÏÎÎÏÎ ÏÏÎ ÏÎÏÎÎ ÎÎÎÏÎÎ ÎÏÏÎÎÎÎÎÏÎÏ ÎÎ GStreamer"
+
+#: C/magic-mirror.vala.page:92(p)
+msgid ""
+"The GStreamer multimedia framework is able to handle video from webcams. "
+"Let's add GStreamer to our application and so we can access the video stream."
+msgstr ""
+"Î ÏÎÎÎÎÏÏÏ ÏÎÎÏÎÎÏÏÎ GStreamer ÎÎÎÎÎ ÎÎÎÎÏÏ ÏÏÎ ÏÎÎÏÎÏÎÏ ÎÎÎÏÎÎ ÎÏÏ "
+"ÎÏÏÎÎÎÎÎÏÎÏ. ÎÏ ÏÏÎÏÎÎÏÎÏÎÎ ÏÎ GStreamer ÏÏÎÎ ÎÏÎÏÎÎÎÎ ÎÎÏ ÎÎÎ ÎÏÏÎ ÎÏÎÏÎÏÎÎ "
+"ÎÎ ÏÏÎÏÏÎÎÎÏÎÏÎÎ ÏÎ ÏÎÏÎÎ ÎÎÎÏÎÎ."
+
+#: C/magic-mirror.vala.page:119(p)
+msgid ""
+"First we remove the window we created before because GStreamer will take "
+"care of showing the picture on screen."
+msgstr ""
+"ÎÏÏÏÎ ÎÏ ÎÏÎÎÏÎÏÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÎÏÏÎÎÏÎÎÎ ÏÏÎÎ ÎÏÎÎÎÎ ÏÎ GStreamer "
+"ÎÎ ÏÏÎÎÏÎÏÎÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÎÎÏÎÎÏ ÏÏÎÎ ÎÎÏÎÎ."
+
+#: C/magic-mirror.vala.page:123(p)
+msgid ""
+"Now we are creating a GStreamer element which accesses our webcam. We are "
+"using the Camerabin element, which is an all-in-one camera element and is "
+"capable of taking photos, videos, applying effects and much more. Perfect "
+"for our use case! With <code>this.camerabin.set_state (Gst.State.PLAYING)</"
+"code> we tell the GStreamer pipeline we just created to start playing. Easy, "
+"no?"
+msgstr ""
+"ÎÏÏÎ ÎÎÎÎÎÏÏÎÎÏÎÎ ÎÎÎ ÏÏÎÎÏÎÎÎ GStreamer ÏÎÏ ÏÏÎÏÏÎÎÎÎÎÎ ÏÎÎ ÎÏÏÎÎÎÎÎÏÎ ÎÎÏ. "
+"ÎÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÏÏÎÎÏÎÎÎ Camerabin, ÏÎÏ ÎÎÎÎÎ ÎÎÎ ÏÏÎÎÏÎÎÎ ÎÎÎÎÏÎÏ ÏÎÎ ÏÎ "
+"ÎÎÎ ÎÎÎ ÎÏÎÏÎÎ ÎÎ ÏÎÎÏÎÎÎ ÏÏÏÎÎÏÎÏÎÎÏ, ÎÎÎÏÎÎ ÎÎ ÎÏÎÏÎÏÎÎÎ ÎÏÎ ÎÎÎ ÏÎÎÏ "
+"ÏÎÏÎÏÏÏÏÎÏÎ. ÎÎÎÎÎÎ ÎÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ ÏÏÎÏÎÏ ÎÎÏ! ÎÎ ÏÎÎ "
+"<code>this.camerabin.set_state (Gst.State.PLAYING)</code> ÎÎÎÎ ÏÏÎ ÏÏÎÎÎÏÏÎ "
+"GStreamer ÏÎÏ ÎÏÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎÎÎÎ. ÎÎÎ ÎÎÎÎÎ ÎÏÎÎÎÎ;"
+
+#: C/magic-mirror.vala.page:130(p)
+msgid ""
+"Of course it is also possible to integrate the video more tighly into other "
+"windows but that is an advanced topic that includes some details of the X "
+"Window System we will omit here."
+msgstr ""
+"ÎÏÏÎÎÎ ÎÎÎÎÎ ÎÏÎÏÎÏ ÎÏÎÎÏÏ ÎÎ ÎÎÏÏÎÎÏÏÏÎÏÎÎ ÏÎ ÎÎÎÏÎÎ ÏÎÎ ÏÏÎÎÏÎ ÏÏÎ ÎÎÎÎ "
+"ÏÎÏÎÎÏÏÎ, ÎÎÎÎ ÎÏÏÏ ÎÎÎÎÎ ÏÏÎÏÏÏÎÎÎÎÎ ÎÎÎÎ ÏÎÏ ÏÎÏÎÎÎÎÎÎÎÎÎ ÎÎÏÎÎÎÏ "
+"ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÏÏÎÎÎÏÎÏ ÏÎÏÎÎÏÏÎÏ Î ÏÎÏ ÎÎ ÏÎÏÎÎÎÎÏÎÏÎÎ ÎÎÏ."
+
+#: C/magic-mirror.vala.page:134(p)
+msgid ""
+"Compile and run it again. You will end up with two windows. In the next step "
+"we will integrate the video into the GTK+ window."
+msgstr ""
+"ÎÎÏÎÎÎÏÏÏÎÏÎ ÎÎÎ ÏÏÎÎÎÎÎ ÏÎÏ ÏÎÎÎ. ÎÎ ÎÎÏÎÎÎÎÎÏÎ ÎÎ ÎÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎ "
+"ÎÏÏÎÎÎÎ ÎÎÎÎ ÎÎ ÎÎÏÏÎÎÏÏÏÎÏÎÎ ÏÎ ÎÎÎÏÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ GTK+."
+
+#: C/magic-mirror.vala.page:144(p)
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"magic-mirror/magic-mirror.vala\">reference code</link>. There "
+"is also a more <link href=\"magic-mirror/magic-mirror-advanced.vala"
+"\">extensive implementation</link> that embeds the window into a regular Gtk."
+"Window which involves some advanced techniques, and adds buttons to start/"
+"stop the picture."
+msgstr ""
+"ÎÎÎ ÎÏÎÏÎ ÏÏÎÎÎÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ ÏÎÎ "
+"<link href=\"magic-mirror/magic-mirror.vala\">ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>. ÎÏÎÏÏÎÎ "
+"ÎÏÎÏÎÏ ÎÎÎ ÏÎÎ <link href=\"magic-mirror/magic-mirror-"
+"advanced.vala\">ÎÎÏÎÏÎÎÎÎÎ ÏÎÎÏÎÎÎÏÎ</link> ÏÎÏ ÎÎÏÏÎÎÏÏÎÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÏÎ "
+"ÎÎÎ ÎÎÎÎÎÎÎÏ Gtk.Window ÏÎÏ ÎÎÏÎÏÎÎÏÎÎ ÎÎÏÎÎÎÏ ÏÏÎÏÏÏÎÎÎÎÎÏ ÏÎÏÎÎÎÎÏ ÎÎÎ "
+"ÏÏÎÏÎÎÏÎÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎÎÏÎÎ/ÏÏÎÎÎÏÎÎÎ ÏÎÏ ÎÎÎÏÎÎÏ."
+
+#: C/magic-mirror.vala.page:150(title) C/guitar-tuner.vala.page:258(title)
+msgid "Further reading"
+msgstr "ÎÎÏÎÎÏÎÏÏ ÎÎÎÎÎÏÏÎ"
+
+#: C/magic-mirror.vala.page:151(p)
+msgid ""
+"To find out more about the Vala programming language you might want to check "
+"out the <link href=\"http://live.gnome.org/Vala/Tutorial\";>Vala Tutorial</"
+"link>."
+msgstr ""
+"ÎÎÎ ÎÎ ÎÏÎÎÏÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎ ÏÎ ÎÎÏÏÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Vala ÎÏÏÏ ÎÎÎÎÏÎ ÎÎ "
+"ÎÎÎÎÎÎÏÎ ÏÎ <link href=\"http://live.gnome.org/Vala/Tutorial\";>ÎÎÎÎÎÎ "
+"Vala</link>."
+
+#: C/magic-mirror.vala.page:156(title)
+msgid "Conclusion"
+msgstr "ÎÏÎÏÎÏÎÏÎÎ"
+
+#: C/magic-mirror.vala.page:157(p)
+msgid ""
+"That's it, you have managed to create a full-featured webcam photo "
+"application in 15 minutes. Now you can shave your beard off or add some "
+"makeup to your beautiful face, right before having a beautiful day at your "
+"workplace, where you can impress your friends and colleagues with an awesome "
+"application you just made in 15 minutes."
+msgstr ""
+"ÎÏÏÏ ÎÎÎÎÎ, ÎÎÏÎÏÎÏÏÎÏÎ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎ ÏÎÎÏÎ ÎÏÎÏÎÎÎÎ ÏÏÏÎÎÏÎÏÎÎÏ "
+"ÎÏÏÎÎÎÎÎÏÎÏ ÏÎ 15 ÎÎÏÏÎ. ÎÏÏÎ ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÏÎÏÏÎÎÏÎ Î ÎÎ ÏÏÎÏÎÎÏÎÏÎ "
+"ÎÎÎÎÏÎÏÎÎÎ ÏÏÎ ÏÎÎÏÏÏ ÏÎÏ ÏÏÏÏÏÏÎ, ÎÎÏÎÎÏÏ ÏÏÎÎ ÎÎ ÎÏÎÏÎ ÎÎÎ ÏÎÎÏÏÎ ÎÎÎÏÎ "
+"ÏÏÎ ÎÎÏÎÎÎÎ ÏÎÏ, ÏÏÎÏ ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÏÏÏÏÏÎÎÏÎÏÎ ÏÎÏÏ ÏÎÎÎÏÏ ÏÎÏ ÎÎÎ "
+"ÏÏÎÎÎÎÎÏÎÏÏ ÏÎÏ ÎÎ ÎÎÎ ÏÎÎÎÏÎ ÎÏÎÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎÎÏÎ ÏÎ 15 ÎÎÏÏÎ."
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/linkbutton.py.page:21(None) C/linkbutton.js.page:20(None)
+msgid "@@image: 'media/linkbutton.png'; md5=3712eae8953e87c65a6aa74503b8e32b"
+msgstr "@@image: 'media/linkbutton.png'Â md5=3712eae8953e87c65a6aa74503b8e32b"
+
+#: C/linkbutton.py.page:16(desc)
+msgid "A button bound to an URL"
+msgstr "ÎÎÎ ÎÎÏÎÏÎ ÎÎÏÎÎÏÎÎÎÎ ÏÎ ÎÎÎ URL"
+
+#: C/linkbutton.py.page:19(title)
+msgid "LinkButton widget"
+msgstr "ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ LinkButton"
+
+#: C/linkbutton.py.page:22(p)
+msgid "A button that links to a web page."
+msgstr "ÎÎÎ ÎÎÏÎÏÎ ÏÎÏ ÏÏÎÎÎÎÎ ÏÎ ÎÏÏÎÏÎÎÎÎÎ."
+
+#: C/linkbutton.py.page:31(link)
+msgid "GtkLinkButton"
+msgstr "GtkLinkButton"
+
+#: C/linkbutton.js.page:16(desc)
+msgid "A button that links to a web page"
+msgstr "ÎÎÎ ÎÎÏÎÏÎ ÏÎÏ ÏÏÎÎÎÎÎ ÏÎ ÎÏÏÎÏÎÎÎÎÎ"
+
+#: C/linkbutton.js.page:19(title)
+msgid "LinkButton"
+msgstr "LinkButton"
+
+#: C/linkbutton.js.page:21(p)
+msgid "A button that links to live.gnome.org."
+msgstr "ÎÎÎ ÎÎÏÎÏÎ ÏÎÏ ÏÏÎÎÎÎÎ ÎÎ ÏÎ live.gnome.org."
+
+#: C/linkbutton.js.page:30(link)
+msgid "Gtk.LinkButton"
+msgstr "Gtk.LinkButton"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/label.vala.page:20(None) C/label.py.page:20(None)
+#: C/label.js.page:20(None) C/label.c.page:23(None)
+#| msgid ""
+#| "@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+msgid "@@image: 'media/label.png'; md5=734975c18653d88379f983e4501c3fc0"
+msgstr "@@image: 'media/label.png'Â md5=734975c18653d88379f983e4501c3fc0"
+
+#: C/label.vala.page:16(desc) C/label.py.page:16(desc) C/label.c.page:16(desc)
+msgid "A widget which displays text"
+msgstr "ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ ÎÎÏÎÎÎÎÎÎ ÎÎÎÎÎÎÎ"
+
+#: C/label.vala.page:19(title) C/label.py.page:19(title)
+#: C/label.js.page:19(title) C/label.c.page:19(title)
+msgid "Label"
+msgstr "ÎÏÎÎÎÏÎ"
+
+#: C/label.vala.page:21(p) C/label.py.page:21(p) C/label.c.page:24(p)
+msgid "A simple label"
+msgstr "ÎÎÎ ÎÏÎÎ ÎÏÎÎÎÏÎ"
+
+#: C/label.vala.page:31(link) C/label.js.page:30(link)
+#: C/dialog.vala.page:32(link)
+msgid "Gtk.Label"
+msgstr "Gtk.Label"
+
+#: C/label.js.page:16(desc)
+msgid "A label which can contain text"
+msgstr "ÎÎÎ ÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎÎÎÎÎ"
+
+#: C/label.js.page:21(p)
+msgid "A label displaying a friendly message."
+msgstr "ÎÎÎ ÎÏÎÎÎÏÎ ÏÎÏ ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÏÎÎÎÎÏ ÎÎÎÏÎÎ."
+
+#: C/label.c.page:11(name) C/image.c.page:11(name)
+msgid "Monica Kochofar"
+msgstr "Monica Kochofar"
+
+#: C/label.c.page:12(email) C/image.c.page:12(email)
+msgid "monicakochofar gmail com"
+msgstr "monicakochofar gmail com"
+
+#: C/js.page:7(title)
+msgid "JavaScript"
+msgstr "JavaScript"
+
+#: C/js.page:16(title)
+msgid "Tutorials, code samples and platform demos in JavaScript"
+msgstr "ÎÎÎÎÎÎÏÎ, ÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ ÎÎÎ ÏÎÏÎÏÏÎÎÏÎÎÏ ÏÎÎÏÏÏÏÎÎÏ ÏÏÎ JavaScript"
+
+#: C/index.page:7(name)
+#| msgid "GNOME Documentation Project"
+msgid "GNOME Documentation Team"
+msgstr "ÎÎÎÎÎ ÏÎÎÎÎÏÎÏÏÎÏ GNOME"
+
+#: C/index.page:9(years)
+msgid "2010, 2011"
+msgstr "2010, 2011"
+
+#: C/index.page:27(title)
+msgid "GNOME Developer Platform Demos"
+msgstr "ÎÎÏÎÏÏÎÎÏÎÎÏ ÏÎÎÏÏÏÏÎÎÏ ÎÎÎÏÏÏÎÎÏ GNOME"
+
+#: C/index.page:30(title)
+msgid "How to set up your development environment"
+msgstr "ÎÏÏ ÎÎ ÎÎÎÎÏÎÏÏÎÏÎÏÎ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÎÎÎÏÏÏÎÎÏ"
+
+#: C/index.page:34(title)
+msgid "Tutorials, code samples, platform demos and more"
+msgstr "ÎÎÎÎÎÎÏÎ, ÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ, ÏÎÏÎÏÏÎÎÏÎÎÏ ÏÎÎÏÏÏÏÎÎÏ ÎÎÎ ÎÎÎÎ"
+
+#: C/index.page:38(title)
+msgid "Get Involved"
+msgstr "ÎÏÎÎÎÏÎÏÎ"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/image-viewer.vala.page:47(None) C/image-viewer.py.page:41(None)
+#: C/image-viewer.js.page:42(None) C/image-viewer.cpp.page:31(None)
+#: C/image-viewer.c.page:32(None)
+msgid "@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+msgstr ""
+"@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+
+#: C/image-viewer.vala.page:9(desc) C/image-viewer.c.page:9(desc)
+#| msgid ""
+#| "A little bit more than a simple \"Hello world\" application - write an "
+#| "image viewer in GTK."
+msgid "A little bit more than a simple \"Hello world\" Gtk application."
+msgstr "ÎÎÏÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÏÏ ÎÏÎÎ ÎÏÎÏÎÎÎÎ Gtk ÏÏÏÏ ÏÎ \"ÎÎÎÎ ÏÎÏ ÎÏÏÎÎ\"."
+
+#: C/image-viewer.vala.page:21(name)
+msgid "Philip Chimento"
+msgstr "Philip Chimento"
+
+#: C/image-viewer.vala.page:22(email)
+msgid "philip chimento gmail com"
+msgstr "philip chimento gmail com"
+
+#: C/image-viewer.vala.page:30(title) C/image-viewer.py.page:24(title)
+#: C/image-viewer.js.page:24(title)
+#| msgid "Image Viewer"
+msgid "1 Image Viewer"
+msgstr "1 ÎÏÎÎÎÎÎÎÏ ÎÎÎÏÎÏÎ"
+
+#: C/image-viewer.vala.page:32(p)
+#| 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:"
+msgid ""
+"In this tutorial you will create an application which opens and displays an "
+"image file. You will learn:"
+msgstr ""
+"ÎÎ ÎÏÏÏÎ ÏÎ ÎÎÎÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎ ÎÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎ ÎÎÎ "
+"ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ. ÎÎ ÎÎÎÎÏÎ:"
+
+#: C/image-viewer.vala.page:34(p)
+#| msgid ""
+#| "An installed copy of the <link xref=\"getting-ready\">Anjuta IDE</link>"
+msgid ""
+"How to set up a basic project using the <link xref=\"getting-ready\">Anjuta "
+"IDE</link>."
+msgstr ""
+"ÎÏÏ ÎÎ ÎÎÎÎÏÎÏÏÎÏÎÏÎ ÎÎÎ ÎÎÏÎÎÏ ÎÏÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ <link xref=\"getting-"
+"ready\">Anjuta IDE</link>."
+
+#: C/image-viewer.vala.page:35(p)
+msgid ""
+"How to write a <link href=\"http://developer.gnome.org/platform-overview/";
+"stable/gtk\">Gtk application</link> in Vala"
+msgstr ""
+"ÎÏÏ ÎÎ ÎÏÎÏÎÏÎ ÎÎÎ <link href=\"http://developer.gnome.org/platform-";
+"overview/stable/gtk\">ÎÏÎÏÎÎÎÎ Gtk</link> ÏÏÎ Vala"
+
+#: C/image-viewer.vala.page:36(p)
+msgid ""
+"Some basic concepts of <link href=\"http://developer.gnome.org/gobject/";
+"stable/\">GObject</link> programming"
+msgstr ""
+"ÎÎÏÎÎÎÏ ÎÎÏÎÎÎÏ ÎÎÎÎÎÎÏ ÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ <link "
+"href=\"http://developer.gnome.org/gobject/stable/\";>GObject</link>"
+
+#: C/image-viewer.vala.page:41(p) C/guitar-tuner.vala.page:37(p)
+#| msgid "Basic knowledge of the python programming language"
+msgid ""
+"Basic knowledge of the <link href=\"https://live.gnome.org/Vala/Tutorial";
+"\">Vala</link> programming language."
+msgstr ""
+"ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ <link "
+"href=\"https://live.gnome.org/Vala/Tutorial\";>Vala</link>."
+
+#: C/image-viewer.vala.page:42(p) C/guitar-tuner.vala.page:38(p)
+#| msgid ""
+#| "An installed copy of the <link xref=\"getting-ready\">Anjuta IDE</link>"
+msgid "An installed copy of <app>Anjuta</app>."
+msgstr "ÎÎÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÎÎÏÎÎÏÎÏÎ ÏÎÏ <app>Anjuta</app>."
+
+#: C/image-viewer.vala.page:43(p)
+msgid ""
+"You may find the <link href=\"http://valadoc.org/gtk+-3.0/\";>gtk+-3.0</link> "
+"API Reference useful, although it is not necessary to follow the tutorial."
+msgstr ""
+"ÎÏÏÏ ÎÏÎÎÏÎ ÏÎÎ ÎÎÎÏÎÏÎ API <link "
+"href=\"http://valadoc.org/gtk+-3.0/\";>gtk+-3.0</link> ÏÏÎÏÎÎÎ, ÎÎ ÎÎÎ ÎÎÎ "
+"ÎÎÎÎÎ ÎÏÎÏÎÎÏÎÏÎ Î ÏÎÏÎÎÎÎÎÏÎÎÏÎ ÏÎÏ ÎÎÎÎÎÎÏÎÏ."
+
+#: C/image-viewer.vala.page:56(p) C/guitar-tuner.vala.page:49(p)
+#| msgid ""
+#| "Start Anjuta and click <guiseq><gui>File</gui><gui>New</gui><gui>Project</"
+#| "gui></guiseq> to open the project wizard."
+msgid ""
+"Start <app>Anjuta</app> and click <gui>Create a new project</gui> or "
+"<guiseq><gui>File</gui><gui>New</gui><gui>Project</gui></guiseq> to open the "
+"project wizard."
+msgstr ""
+"ÎÎÎÎÎÎÏÏÎ ÏÎ <app>Anjuta</app> ÎÎÎ ÏÎÏÎÏÏÎ <gui>ÎÎÎÎÎÏÏÎÎÎ ÎÎÎÏ ÎÏÎÎÏ</gui> "
+"Î <guiseq><gui>ÎÏÏÎÎÎ</gui><gui>ÎÎÎ</gui><gui>ÎÏÎÎ</gui></guiseq> ÎÎÎ ÎÎ "
+"ÎÎÎÎÎÎÏÎ ÏÎÎ ÎÎÎÎÏ ÏÎÏ ÎÏÎÎÏ."
+
+#: C/image-viewer.vala.page:59(p)
+#| 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."
+msgid ""
+"From the <gui>Vala</gui> tab choose <gui>Gtk+ (Simple)</gui>, click "
+"<gui>Continue</gui>, and fill out your details on the next page. Use "
+"<file>image-viewer</file> as project name and directory."
+msgstr ""
+"ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>Vala</gui> ÎÏÎÎÎÎÏÎ <gui>Gtk+ (ÎÏÎÏ)</gui>, ÎÎÎÎ "
+"<gui>ÏÏÎÎÏÎÎÎ</gui> ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÎ ÎÏÏÎÎÎÎ "
+"ÏÎÎÎÎÎ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ <file>image-viewer</file> ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ "
+"ÏÎÏ ÎÎÏÎÎÏÎÎÏ."
+
+#: C/image-viewer.vala.page:63(p)
+msgid ""
+"Make sure that <gui>Use GtkBuilder for user interface</gui> is unchecked as "
+"we will create the UI manually in this tutorial."
+msgstr ""
+"ÎÎÎÎÎÏÎÎÎÏÎ ÏÏÎ ÏÎ <gui>ÏÏÎÏÎ ÏÎÏ GtkBuilder ÎÎÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ</gui> ÎÎÎÎÎ "
+"ÎÏÎÎÎÎÏÏÎ ÎÏÎÎÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎÎ ÏÎÎ UI ÏÎÎÏÎÎÎÎÎÏÎ ÏÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ."
+
+#: C/image-viewer.vala.page:64(p)
+msgid ""
+"You will learn how to use the interface builder in the <link xref=\"guitar-"
+"tuner.vala\">Guitar-Tuner</link> tutorial."
+msgstr ""
+"ÎÎ ÎÎÎÎÏÎ ÏÏÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎÎ ÎÎÏÎÏÎÎÏÎÏÏÎ ÎÎÎÏÎÏÎÏ ÏÏÎ ÎÎÎÎÎÎ <link "
+"xref=\"guitar-tuner.vala\">ÏÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ</link>."
+
+#: C/image-viewer.vala.page:68(p)
+#| 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."
+msgid ""
+"Click <gui>Continue</gui> then <gui>Apply</gui> and the project will be "
+"created for you. Open <file>src/image_viewer.vala</file> from the "
+"<gui>Project</gui> or <gui>File</gui> tabs. You will see this code:"
+msgstr ""
+"ÎÎÏÎÏÏÎ <gui>ÏÏÎÎÏÎÎÎ</gui>, ÎÏÎÎÏÎ <gui>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ "
+"ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÎÏÎÏ. ÎÎÎÎÎÏÎ ÏÎ <file>src/image_viewer.vala</file> ÎÏÏ ÏÎÏ "
+"ÎÎÏÏÎÎÎÏ <gui>ÎÏÎÎ</gui> Î <gui>ÎÏÏÎÎÎ</gui>. ÎÎ ÎÎÎÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ:"
+
+#: C/image-viewer.vala.page:107(p)
+#| 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:"
+msgid ""
+"The code 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 ""
+"Î ÎÏÎÎÎÎÏ ÏÎÏÏÏÎÎÎ ÎÎÎ (ÎÎÎÏ) ÏÎÏÎÎÏÏÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ ÏÎÏÎÎÏÎÏÎÏ ÎÎÎÏÎÏÎÏ "
+"ÏÏÎÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÎÎÎÎÎ. ÎÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏÏÎÏÎ ÏÎÎ ÎÎÏÏÂ "
+"ÏÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎ ÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎ ÎÎÏÎÎÎ:"
+
+#: C/image-viewer.vala.page:112(p)
+msgid ""
+"The two <code>using</code> lines at the top import namespaces so we don't "
+"have to name them explicitly."
+msgstr ""
+"ÎÎ ÎÏÎ ÎÏÎÎÎÎÏ <code>using</code> ÏÏÎÎ ÎÎÏÏÏÎ ÎÎÏÎÎÎÏÎ ÏÎÏÏ ÏÏÏÎÏÏ ÎÎÎÎÎÏÏÎ, "
+"ÎÏÏÎ ÏÏÏÎ ÎÎ ÎÎÎ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÏÎ ÏÎÏÎ."
+
+#: C/image-viewer.vala.page:115(p)
+msgid ""
+"The constructor of the <code>Main</code> class creates a new (empty) window "
+"and connects a <link href=\"https://live.gnome.org/Vala/SignalsAndCallbacks";
+"\">signal</link> to exit the application when that window is closed."
+msgstr ""
+"Î ÎÎÏÎÏÎÎÏÎÏÏÎÏ ÏÎÏ ÎÎÎÏÎÏ <code>Main</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÎ (ÎÎÎÏ) "
+"ÏÎÏÎÎÏÏÎ ÎÎÎ ÏÏÎÎÎÎÎ ÎÎÎ <link "
+"href=\"https://live.gnome.org/Vala/SignalsAndCallbacks\";>ÏÎÎÎ</link> ÎÎÎ ÎÎÎÎÎ "
+"ÎÏÏ ÏÎÎ ÎÏÎÏÎÎÎÎ, ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÏÎÎ."
+
+#: C/image-viewer.vala.page:116(p) C/image-viewer.c.page:68(p)
+#: C/guitar-tuner.c.page:73(p)
+#| 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."
+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> function is "
+"called (and quits the app) when you close the window."
+msgstr ""
+"ÎÏÎÎÎÏÎ ÏÎÎÎÏÏÎ ÎÎÎÎÎ ÏÏÏ ÎÎÎÎÏÎÎÎÏÎ ÏÎ ÏÏÎÎÎÎÎÎÎ ÏÏÎÎ ÏÎÏÎÏÎ ÎÎÎ ÎÎÏÎÏÎ, Î "
+"ÏÏÎÎ ÏÏÎÎÎÎ ÎÎÏÎÎÎ ÎÎÎÎ ÏÏÎÎÎÎ. ÎÎÏ, ÎÎÎÎÎÏÎÎ Î ÏÏÎÎÏÏÎÏÎ "
+"<code>destroy</code> (ÎÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ) ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÏÎ "
+"ÏÎÏÎÎÏÏÎ."
+
+#: C/image-viewer.vala.page:120(p)
+msgid ""
+"The <code>static main</code> function is run by default when you start a "
+"Vala application. It calls a few functions which create the <code>Main</"
+"code> class, set up and then run the application. The <link href=\"http://";
+"valadoc.org/gtk+-3.0/Gtk.main.html\"><code>Gtk.main</code></link> function "
+"starts the GTK <link href=\"http://en.wikipedia.org/wiki/Event_loop\";>main "
+"loop</link>, which runs the user interface and starts listening for events "
+"(like clicks and key presses)."
+msgstr ""
+"Î ÏÏÎÎÏÏÎÏÎ <code>static main</code> ÏÏÎÏÎÎ ÎÏÏ ÏÏÎÎÏÎÎÎÎÎ ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÎÎÎ "
+"ÎÏÎÏÎÎÎÎ Vala. ÎÎÎÎÎ ÎÎÎÎÏ ÏÏÎÎÏÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎÎ ÎÎÎÏÎ "
+"<code>Main</code>, ÏÏÎÎÎÎÎÏÎ ÎÎÎ ÎÎÏÎ ÏÏÎÏÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ. Î ÏÏÎÎÏÏÎÏÎ "
+"<link href=\"http://valadoc.org/gtk+-3.0/Gtk.main.html\";><code>Gtk.main</code>"
+"</link> ÎÎÎÎÎÎ ÏÎÎ GTK <link "
+"href=\"http://en.wikipedia.org/wiki/Event_loop\";>ÎÏÏÎÎÏ ÎÏÏÏÎÏ</link>, ÏÎÏ "
+"ÏÏÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÎÎÎ ÎÎÎÎÎÎ ÎÎÏÏÎÏÎ ÏÏÎ ÏÏÎÎÎÎÏÏÎ (ÏÏÏÏ ÎÎÎÎ ÎÎÎ "
+"ÏÎÏÎÎÎÏÎ ÏÎÎÎÏÏÎÏ)."
+
+#: C/image-viewer.vala.page:132(title) C/image-viewer.cpp.page:81(title)
+#: C/image-viewer.c.page:83(title)
+#| msgid "Create the user interface"
+msgid "Creating the user interface"
+msgstr "ÎÎÎÎÎÏÏÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ"
+
+#: C/image-viewer.vala.page:133(p)
+msgid ""
+"Now we will bring life into the empty window. GTK organizes the user "
+"interface with <link href=\"http://www.valadoc.org/gtk+-2.0/Gtk.Container.";
+"html\"><code>Gtk.Container</code></link>s that can contain other widgets and "
+"even other containers. Here we will use the simplest available container, a "
+"<link href=\"http://unstable.valadoc.org/gtk+-2.0/Gtk.Box.html\";><code>Gtk."
+"Box</code></link>."
+msgstr ""
+"ÎÏÏÎ ÎÎ ÎÏÏÎÏÎÎ ÎÏÎ ÏÎ ÎÎÎ ÎÎÎÎÎ ÏÎÏÎÎÏÏÎ. ÎÎ GTK ÎÏÎÎÎÏÎÎÎ ÏÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎÏÏÎ ÎÎ <link href=\"http://www.valadoc.org/gtk+-2.0/Gtk.Container.html\";><c"
+"ode>Gtk.Container</code></link> ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ ÏÎÏÎÎÏÎÏÎ ÎÎÎÎ ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ ÎÎÎ ÎÎÏÎÎ ÎÎÎÎÏÏ ÏÎÏÎÎÎÏÎÏ. ÎÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎÎ ÎÏÎÎÏÏÏÎÏÎ "
+"ÎÎÎÎÎÏÎÎÎ ÏÎÏÎÎÎÏÎ, ÎÎÎ <link href=\"http://unstable.valadoc.org/gtk+-2.0/Gt";
+"k.Box.html\"><code>Gtk.Box</code></link>."
+
+#: C/image-viewer.vala.page:137(p)
+msgid "Add the following lines to the top of the <code>Main</code> class:"
+msgstr ""
+"ÎÏÎÏÎÎÏÏÎ ÏÎÏ ÎÏÏÎÎÎÎÏ ÎÏÎÎÎÎÏ ÏÏÎÎ ÎÎÏÏÏÎ ÏÎÏ ÎÎÎÏÎÏ <code>Main</code>:"
+
+#: C/image-viewer.vala.page:143(p)
+msgid "Now replace the current constructor with the one below:"
+msgstr "ÎÏÏÎ ÎÎÏÎÎÎÏÎÏÏÎÏÏÎ ÏÎÎ ÏÏÎÏÎÎÏÎ ÎÎÏÎÏÎÎÏÎÏÏÎ ÎÎ ÏÎÎ ÏÎÏÎÎÎÏÏ:"
+
+#: C/image-viewer.vala.page:169(p)
+msgid ""
+"The first two lines are the parts of the GUI that we will need to access "
+"from more than one method. We declare them up here so that they are "
+"accessible throughout the class instead of only in the method where they are "
+"created."
+msgstr ""
+"ÎÎ ÏÏÏÏÎÏ ÎÏÎ ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÎÎÏÎ ÏÎÏ GUI ÏÎÏ ÎÎ ÏÏÎÎÎÏÏÎÏÎ ÏÏÏÏÎÎÏÎ ÎÏÏ "
+"ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÏÏ ÎÎÎ ÎÎÎÏÎÎÏÏ. ÎÎÏ ÎÎÎÏÎÎÏÎÎ ÎÎÏ ÎÏÏÎ ÏÏÏÎ ÎÎ ÎÎÎÎÎ "
+"ÏÏÎÏÎÎÏÎÎÎÏ ÎÎÏÎ ÎÏÏ ÏÎÎ ÎÎÎÏÎ ÎÎÏÎ ÎÏÎÎ ÎÏÏ ÏÎ ÎÎÎÎÎÎ ÏÏÎÏ ÎÎÎÎÎÏÏÎÎÏÎÏÎÎ."
+
+#: C/image-viewer.vala.page:173(p)
+msgid ""
+"The first lines of the constructor create the empty window. The next lines "
+"create the widgets we want to use: a button for opening up an image, the "
+"image view widget itself and the box we will use as a container."
+msgstr ""
+"ÎÎ ÏÏÏÏÎÏ ÎÏÎÎÎÎÏ ÏÎÏ ÎÎÏÎÏÎÎÏÎÏÏÎ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎ ÎÎÎÎÎ ÏÎÏÎÎÏÏÎ. ÎÎ "
+"ÎÏÏÎÎÎÎÏ ÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÎÏ ÎÎÎÎÏÎÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ: ÎÎÎ ÎÎÏÎÏÎ ÎÎÎ ÎÎÎÎÎÎÎ ÎÎÎÏ ÎÎÎÏÎÎÏ, ÏÎ ÎÎÎÎ ÏÎ ÎÏÎÏÎÎÏ "
+"ÏÏÏÏÎÏÎÎÏ ÏÏÎÎÎÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ ÎÎÎ ÏÎ ÏÎÎÎÏÎÎ ÏÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÏ "
+"ÏÎÏÎÎÎÏÎ."
+
+#: C/image-viewer.vala.page:177(p)
+msgid ""
+"The calls to <link href=\"http://unstable.valadoc.org/gtk+-2.0/Gtk.Box.";
+"pack_start.html\"><code>pack_start</code></link> add the two widgets to the "
+"box and define their behaviour. The image will expand into any available "
+"space whereas the button will just be as big as needed. You will notice that "
+"we don't set explicit sizes on the widgets. In GTK this is usually not "
+"needed as it makes it much easier to have a layout that looks good in "
+"different window sizes. Next, the box is added to the window."
+msgstr ""
+"ÎÎ ÎÎÎÏÎÎÏ ÏÏÎ <link href=\"http://unstable.valadoc.org/gtk+-2.0/Gtk.Box.pack";
+"_start.html\"><code>pack_start</code></link> ÏÏÎÏÎÎÏÎÏÎ ÏÎ ÎÏÎ ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ ÏÏÎ ÏÎÎÎÏÎÎ ÎÎÎ ÎÏÎÎÎÏÎ ÏÎ ÏÏÎÏÎÏÎÏÎÏÎ ÏÎÏÏ. Î ÎÎÎÏÎÎ ÎÎ ÎÏÎÎÏÎÎÎÎ "
+"ÏÎ ÎÎÎÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ ÎÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎ ÎÎÎÎÎ ÎÏÎÎ ÏÏÏÎ ÎÎÎÎÎÎ ÏÏÎ "
+"ÏÏÎÎÎÎÎÏÎÎ. ÎÎ ÏÎÏÎÏÎÏÎÏÎÏÎ ÏÏÎ ÎÎÎ ÎÏÎÎÎÏÎÎ ÏÎÏÎ ÎÎÎÎÎÎ ÏÏÎ ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ. ÎÏÎ GTK ÎÏÏÏ ÏÏÎÎÎÏÏ ÎÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÏÎÎÎÎ ÎÎÎÎÎ ÏÎÎ ÎÏÎÏ ÎÎ "
+"ÎÏÎÏÎ ÎÎÎ ÎÎÎÏÎÎÎ ÏÎÏ ÏÎÎÎÎÏÎÎ ÎÎÎÎ ÎÎ ÎÎÎÏÎÏÎÏÎÎÎ ÎÎÎÎÎÎ ÏÎÏÎÎÏÏÏÎ. ÎÏÎ "
+"ÏÏÎÎÏÎÎÎ, ÏÎ ÏÎÎÎÏÎÎ ÏÏÎÏÏÎÎÎÏÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ."
+
+#: C/image-viewer.vala.page:184(p)
+msgid ""
+"We need to define what happens when the user clicks on the button. GTK uses "
+"the concept of <em>signals</em>."
+msgstr ""
+"ÎÏÎÎÎÎÎÏÎÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎÎÎÎÎ ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎ ÏÎ ÎÎÏÎÏÎ. ÎÎ GTK "
+"ÏÏÎÏÎÎÎÏÎÎÎÎ ÏÎÎ ÎÎÎÎÎÎ ÏÏÎ <em>ÏÎÎÎÏÏÎ</em>."
+
+#: C/image-viewer.vala.page:185(p)
+msgid ""
+"When the <link href=\"http://valadoc.org/gtk+-3.0/Gtk.Button.html\";>button</"
+"link> is clicked, it fires the <link href=\"http://valadoc.org/gtk+-3.0/Gtk.";
+"Button.clicked.html\"><code>clicked</code></link> signal, which we can "
+"connect to some action (defined in a <link href=\"https://live.gnome.org/";
+"Vala/SignalsAndCallbacks\">callback</link> method)."
+msgstr ""
+"ÎÏÎÎ ÏÎ <link "
+"href=\"http://valadoc.org/gtk+-3.0/Gtk.Button.html\";>ÎÎÏÎÏÎ</link> ÏÎÏÎÎÏÎÎ "
+"ÏÏÎÎÎÎÎÎ ÏÎ ÏÎÎÎ <link href=\"http://valadoc.org/gtk+-3.0/Gtk.Button.clicked.";
+"html\"><code>clicked</code></link>, ÏÎÏ ÎÏÎÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÎÎ ÎÎÏÎÎÎ "
+"ÎÎÎÏÎÎÎÎ (ÎÏÎÏÎÎÎÎ ÏÎ ÎÎÎ ÎÎÎÎÎÎ <link "
+"href=\"https://live.gnome.org/Vala/SignalsAndCallbacks\";>ÎÏÎÎÎÎÎÎÏÎÏ</link>)."
+
+#: C/image-viewer.vala.page:188(p)
+msgid ""
+"This is done using the <code>connect</code> method of the button's "
+"<code>clicked</code> signal, which in this case tells GTK to call the (yet "
+"undefined) <code>on_image_open</code> callback method when the button is "
+"clicked. We will define the <em>callback</em> in the next section."
+msgstr ""
+"ÎÏÏÏ ÎÎÎÎÏÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÎÎÎÎÎÎ <code>connect</code> ÏÎÏ ÏÎÎÎÏÎÏ ÏÎÏ "
+"ÎÎÏÎÏÎÎÏ <code>clicked</code>, ÏÎÏ ÏÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÎÎ ÏÏÎ GTK ÎÎ "
+"ÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎÎ ÎÏÎÎÎÎÎÎÏÎÏ (ÎÏÏÎÏÏÎ ÎÎÏÎÎ) <code>on_image_open</code> "
+"ÏÏÎÎ ÏÎ ÎÎÏÎÏÎ ÏÎÏÎÎÏÎÎ. ÎÎ ÎÏÎÏÎÏÎÎ ÏÎÎ <em>ÎÏÎÎÎÎÎÎÏÎ</em> ÏÏÎÎ ÎÏÏÎÎÎÎ "
+"ÎÎÏÏÎÏÎ."
+
+#: C/image-viewer.vala.page:192(p)
+msgid ""
+"In the callback, we need to access the <code>window</code> and <code>image</"
+"code> widgets, which is why we defined them as private members at the top of "
+"our class."
+msgstr ""
+"ÎÏÎÎ ÎÏÎÎÎÎÎÎÏÎ, ÏÏÎÎÎÎÏÎÎÏÏÎ ÎÎ ÏÏÎÏÏÎÎÎÏÎÏÎÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ "
+"<code>window</code> ÎÎÎ <code>image</code>, ÎÎ' ÎÏÏÏ ÏÎ ÎÏÎÎÎÏÎÎ ÏÏ ÎÎÎÏÏÎÎÎ "
+"ÎÎÎÎ ÏÏÎÎ ÎÎÏÏÏÎ ÏÏÎ ÎÎÎÏÎÏÎ ÎÎÏ."
+
+#: C/image-viewer.vala.page:196(p)
+msgid ""
+"The last <code>connect</code> call makes sure that the application exits "
+"when the window is closed. The code generated by Anjuta called an "
+"<code>on_destroy</code> callback method which called <link href=\"http://www.";
+"valadoc.org/gtk+-2.0/Gtk.main_quit.html\"><code>Gtk.main_quit</code></link>, "
+"but just connecting our signal to <code>main_quit</code> directly is easier. "
+"You can delete the <code>on_destroy</code> method."
+msgstr ""
+"Î ÏÎÎÎÏÏÎÎÎ ÎÎÎÏÎ <code>connect</code> ÎÎÎÎÎÏÎÎÏÎÎ ÏÏÎ Î ÎÏÎÏÎÎÎÎ ÎÎÎÏÏÎÏÎÎ "
+"ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÎÎ. Î ÎÎÎÎÎÏÏÎÎÏÎÎÎÎÏ ÎÏÎÎÎÎÏ ÎÏÏ ÏÎ Anjuta ÎÎÎÎÏÎ ÎÎÎ "
+"ÎÎÎÎÎÎ ÎÏÎÎÎÎÎÎÏÎÏ <code>on_destroy</code> ÏÎÏ ÎÎÎÎÏÎ <link href=\"http://ww";
+"w.valadoc.org/gtk+-2.0/Gtk.main_quit.html\"><code>Gtk.main_quit</code></link>"
+", ÎÎÎÎ Î ÏÏÎÎÎÏÎ ÏÎÏ ÏÎÎÎÏÎÏ ÎÎÏ ÏÏÎ <code>main_quit</code> ÎÎÎÏÎ ÎÎÎÎÎ "
+"ÎÏÎÎÎÏÏÎÏÎ. ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎÏÎÏÎÏÎ ÏÎ ÎÎÎÎÎÎ <code>on_destroy</code>."
+
+#: C/image-viewer.vala.page:203(title) C/image-viewer.cpp.page:136(title)
+#: C/image-viewer.c.page:148(title)
+msgid "Showing the image"
+msgstr "ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÎÎÏÎÎÏ"
+
+#: C/image-viewer.vala.page:204(p)
+msgid ""
+"We will now define the signal handler for the <code>clicked</code> signal "
+"for the button we mentioned before. Add this code after the constructor:"
+msgstr ""
+"ÎÎ ÎÏÎÏÎÏÎÎ ÏÏÏÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÎÏ ÎÎÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÎÎÎ "
+"ÏÎ ÎÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÏÎÎÎ ÏÏÎÎ. ÎÏÎÏÎÎÏÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÎÎÏÎ ÏÎÎ "
+"ÎÎÏÎÏÎÎÏÎÏÏÎ:"
+
+#: C/image-viewer.vala.page:230(p)
+#| msgid ""
+#| "This is a bit more complicated than anything we've attempted so far, so "
+#| "let's break it down:"
+msgid "This is a bit complicated, so let's break it down:"
+msgstr "ÎÏÏÏ ÎÎÎÎÎ ÎÎÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎ, ÎÎÎÏÏÏ ÎÏ ÏÎ ÏÏÏÎÏÎÏÎÎ:"
+
+#: C/image-viewer.vala.page:231(p)
+msgid ""
+"A signal handler is a type of callback method that is called when a signal "
+"is emitted. Here the terms are used interchangeably."
+msgstr ""
+"ÎÎÎÏ ÏÎÎÏÎÏÏÎÏ ÏÎÎÎÏÎÏ ÎÎÎÎÎ ÎÎÎÏ ÏÏÏÎÏ ÏÎÏ ÎÎÎÏÎÎÏ ÎÏÎÎÎÎÎÎÏÎÏ ÏÎÏ ÎÎÎÎÎÏÎÎ "
+"ÏÏÎÎ ÎÎÎ ÏÎÎÎ ÎÎÏÎÎÏÎÏÎÎ. ÎÎÏ ÎÎ ÏÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎÎÎÎÎÏÎÎÎ."
+
+#: C/image-viewer.vala.page:234(p)
+msgid ""
+"The first argument of the callback method is always the widget that sent the "
+"signal. Sometimes other arguments related to the signal come after that, but "
+"<em>clicked</em> doesn't have any."
+msgstr ""
+"ÎÎ ÏÏÏÏÎ ÏÏÎÏÎÎ ÏÎÏ ÎÎÎÏÎÎÏ ÎÏÎÎÎÎÎÎÏÎÏ ÎÎÎÎÎ ÏÎÎÏÎÏÎ ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ "
+"ÏÎÏ ÎÏÏÎÎÎÎ ÏÎ ÏÎÎÎ. ÎÎÏÎÎÎÏ ÏÎÏÎÏ ÎÎÎÎ ÎÏÎÏÎÎÏÎ ÏÎÏ ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÏÎ ÏÎÎÎ "
+"ÎÏÏÎÎÏÎÎ ÎÎÏÎ ÎÏÏ ÎÏÏÏ, ÎÎÎÎ <em>ÏÎÏÎÎÎÎÎ</em> ÎÎÎ ÎÏÎÎ ÎÎÎÎÎÎ."
+
+#: C/image-viewer.vala.page:236(p)
+msgid ""
+"In this case the <code>button</code> sent the <code>clicked</code> signal, "
+"which is connected to the <code>on_open_image</code> callback method:"
+msgstr ""
+"ÎÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ ÏÎ <code>button</code> ÎÏÏÎÎÎÎ ÏÎ ÏÎÎÎ "
+"<code>clicked</code>, ÏÎÏ ÏÏÎÎÎÎÏÎÎ ÎÎ ÏÎ ÎÎÎÎÎÎ ÎÏÎÎÎÎÎÎÏÎÏ "
+"<code>on_open_image</code>:"
+
+#: C/image-viewer.vala.page:241(p)
+msgid ""
+"The <code>on_open_image</code> method takes the button that emitted the "
+"signal as an argument:"
+msgstr ""
+"Î ÎÎÎÎÎÎÏ <code>on_open_image</code> ÏÎÎÏÎÎÎ ÏÎ ÎÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÎÏÎ ÏÎ ÏÎÎÎ "
+"ÏÏ ÏÏÎÏÎÎ:"
+
+#: C/image-viewer.vala.page:247(p)
+msgid ""
+"The next interesting line is where the dialog for choosing the file is "
+"created. <link href=\"http://www.valadoc.org/gtk+-3.0/Gtk.FileChooserDialog.";
+"html\"><code>FileChooserDialog</code></link>'s constructor takes the title "
+"of the dialog, the parent window of the dialog and several options like the "
+"number of buttons and their corresponding values."
+msgstr ""
+"Î ÎÏÏÎÎÎÎ ÎÎÎÎÎÏÎÏÎÏÏÎ ÎÏÎÎÎÎ ÎÎÎÎÎ ÏÏÎÎ Î ÎÎÎÎÎÎÎÏ ÎÏÎÎÎÎÎÏ ÏÎÏ ÎÏÏÎÎÎÏ "
+"ÎÎÎÎÎÏÏÎÎÎÏÎÎ. ÎÎ <link href=\"http://www.valadoc.org/gtk+-3.0/Gtk.FileChoose";
+"rDialog.html\"><code>FileChooserDialog</code></link> ÏÎÏ ÎÎÏÎÏÎÎÏÎÏÏÎ ÏÎÎÏÎÎÎ "
+"ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎÎÏÎÎÏ, ÏÎ ÎÎÎÏÎ ÏÎÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ ÎÎÎ ÏÎÎÎÎÏ ÎÏÎÎÎÎÎÏ "
+"ÏÏÏÏ Î ÎÏÎÎÎÏÏ ÏÏÎ ÎÎÏÎÏÎÏÎ ÎÎÎ ÎÎ ÎÎÏÎÏÏÎÎÏÎÏ ÏÎÎÎÏ ÏÎÏÏ."
+
+#: C/image-viewer.vala.page:249(p)
+#| 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."
+msgid ""
+"Notice that we are using <link href=\"http://unstable.valadoc.org/gtk+-3.0/";
+"Gtk.Stock.html\"><em>stock</em></link> 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 ""
+"ÎÎÎÎÎÏÏÏÎ ÏÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÎÎÏÎÎÏÎ ÎÎÏÎÏÎÏÎ <link href=\"http://unstabl";
+"e.valadoc.org/gtk+-3.0/Gtk.Stock.html\"><em>ÎÏÎÎÎÎÎÏÎÏ</em></link> ÎÏÏ ÏÎ "
+"Gtk, ÎÎÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎÎÏÎÎÎÎÎÏÎ \"ÎÎÏÏÏÏÎ\" Î \"ÎÎÎÎÎÎÎ\". ÎÎ ÏÎÎÎÎÎÎÏÎÎÎ ÏÎÏ "
+"ÏÏÎÏÎÏ ÏÏÎ ÎÎÎÎÎÏÏÎ ÎÏÎÎÎÎÎÏÎÏ ÎÎÎÎÎ ÏÏÎ ÎÎ ÎÏÎÎÎÏÎÏ ÏÏÎ ÎÎÏÎÏÎÏÎ ÎÎ ÎÏÎÏÎ "
+"ÎÎÎ ÎÎÏÎÏÏÎÏÏÎÎ ÏÏÎ ÎÎÏÏÏÎ ÏÎÏ ÏÏÎÏÏÎ."
+
+#: C/image-viewer.vala.page:253(p)
+#| 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."
+msgid ""
+"The next two lines restrict the <gui>Open</gui> dialog to only display files "
+"which can be opened by <em>GtkImage</em>. GtkImage is a widget which "
+"displays an image. A filter object is created first; we then add all kinds "
+"of files supported by <link href=\"http://www.valadoc.org/gdk-pixbuf-2.0/Gdk.";
+"Pixbuf.html\"><code>Gdk.Pixbuf</code></link> (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>ÎÎÎÎÎÎÎ</gui> ÎÎ "
+"ÎÎÏÎÎÎÎÎÎ ÎÏÎÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÏÎÎÏÎ ÎÏÏ ÏÎ <em>GtkImage</em>. ÎÎ "
+"GtkImage ÎÎÎÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ. ÎÎÎ "
+"ÎÎÏÎÎÎÎÎÎÎÎ ÏÎÎÏÏÎÏ ÎÎÎÎÎÏÏÎÎÎÏÎÎ ÏÏÏÏÎÂ ÎÏÎÎÏÎ ÏÏÎÏÎÎÏÎÏÎÎ ÏÎÎ ÏÎ ÎÎÎÎ ÏÏÎ "
+"ÎÏÏÎÎÏÎ ÏÎÏ ÏÏÎÏÏÎÏÎÎÎÎÏÎÎ ÎÏÏ <link href=\"http://www.valadoc.org/gdk-";
+"pixbuf-2.0/Gdk.Pixbuf.html\"><code>Gdk.Pixbuf</code></link>(ÏÎ ÎÏÎÎÎ "
+"ÏÎÏÎÎÎÎÎÎÎÎÎ ÏÎÏ ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÎÏÏÎÏ ÎÎÎÏÎÏÎ ÏÏÏÏ PNG ÎÎÎ JPEG) ÏÏÎ ÏÎÎÏÏÎ. "
+"ÎÎÎÎÏ, ÎÏÎÎÎÏÎÎ ÎÏÏÏ ÏÎ ÏÎÎÏÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ "
+"<gui>ÎÎÎÎÎÎÎ</gui>."
+
+#: C/image-viewer.vala.page:258(p)
+#| 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."
+msgid ""
+"<link href=\"http://www.valadoc.org/gtk+-3.0/Gtk.Dialog.run.html";
+"\"><code>dialog.run</code></link> 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 <link href=\"http://www.valadoc.org/gtk+-3.0/Gtk.";
+"ResponseType.html\">ResponseType</link> value <code>ResponseType.ACCEPT</"
+"code> (it would return <code>ResponseType.CANCEL</code> if the user clicked "
+"<gui>Cancel</gui>). The <code>switch</code> statement tests for this."
+msgstr ""
+"ÎÎ <link href=\"http://www.valadoc.org/gtk+-3.0/Gtk.Dialog.run.html\";><code>di"
+"alog.run</code></link> ÎÎÏÎÎÎÎÎÎ ÏÎ ÎÎÎÎÎÎÎ <gui>ÎÎÎÎÎÎÎ</gui>. Î ÎÎÎÎÎÎÎÏ "
+"ÎÎ ÏÎÏÎÎÎÎÎÎ ÎÎ ÎÏÎÎÎÎÎÎ Î ÏÏÎÏÏÎÏ ÎÎÎ ÎÎÎÏÎÎÂ ÏÏÎÎ ÎÎÎÎÎ ÏÎ "
+"<code>dialog.run</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÎÎ ÏÎÎÎ <link href=\"http://www.valado";
+"c.org/gtk+-3.0/Gtk.ResponseType.html\">ResponseType</link> "
+"<code>ResponseType.ACCEPT</code> (ÎÎ ÎÏÎÏÎÏÏÎ ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÎ "
+"<code>ResponseType.CANCEL</code> ÎÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÏÎ <gui>ÎÎÏÏÏÏÎ</gui>). "
+"Î ÏÏÏÏÎÏÎ <code>switch</code> ÏÎ ÎÎÎÎÏÎÎ."
+
+#: C/image-viewer.vala.page:263(p)
+#| 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."
+msgid ""
+"Assuming that the user did click <gui>Open</gui>, the next lines get the "
+"filename of the image selected by the user, and tell the <code>GtkImage</"
+"code> widget to load and display the selected image."
+msgstr ""
+"ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎ ÏÎ <gui>ÎÎÎÎÎÎÎ</gui>, ÎÎ ÎÏÏÎÎÎÎÏ "
+"ÎÏÎÎÎÎÏ ÏÎÎÏÎÎÏÎ ÏÎ ÏÎÎÎÎ ÏÎÏ ÎÏÏÎÎÎÏ ÏÎÏ ÎÏÎÎÎÎÎÎÎÎÏ ÎÎÎÏÎÎÏ ÎÏÏ ÏÎÎ ÏÏÎÏÏÎ "
+"ÎÎÎ ÎÎÎÎ ÏÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ <code>GtkImage</code> ÎÎ ÏÎÏÏÏÏÎÎ ÎÎÎ ÎÎ "
+"ÎÎÏÎÎÎÏÎÎ ÏÎÎ ÎÏÎÎÎÎÎÎÎÎ ÎÎÎÏÎÎ."
+
+#: C/image-viewer.vala.page:266(p) C/image-viewer.py.page:213(p)
+#: C/image-viewer.js.page:299(p)
+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>ÎÎÎÎÎÎÎ</gui> ÎÎÎÏÎ ÎÎÎ ÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎ ÏÎÎ."
+
+#: C/image-viewer.vala.page:267(p)
+msgid "Destroying automatically hides the dialog."
+msgstr "Î ÎÏÏÏÎÎÏÎ ÎÎÏÎÏÏÏÎÏÎ ÎÏÏÎÎÎ ÏÎ ÎÎÎÎÎÎÎ."
+
+#: C/image-viewer.vala.page:274(p) C/image-viewer.cpp.page:205(p)
+#: C/image-viewer.c.page:216(p) C/guitar-tuner.vala.page:248(p)
+#: C/guitar-tuner.c.page:251(p)
+#| 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!"
+msgid ""
+"All of the code should now be ready to go. Click <guiseq><gui>Build</"
+"gui><gui>Build Project</gui></guiseq> to build everything again, and then "
+"<guiseq><gui>Run</gui><gui>Execute</gui></guiseq> to start the application."
+msgstr ""
+"ÎÎÎÏ Î ÎÏÎÎÎÎÏ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÏÎÎÎÎÏ ÏÏÏÎ. ÎÎÎÎ "
+"<guiseq><gui>ÎÎÏÎÏÎÎÏÎ</gui><gui>ÎÎÏÎÏÎÎÏÎ ÎÏÎÎÏ</gui></guiseq> ÎÎÎ "
+"ÎÎÎÎÎÏÎÏÎÎÏÎ ÏÏÎ ÏÎÎÏÏÎ ÎÎÎ ÎÏÎÎÏÎ "
+"<guiseq><gui>ÏÏÎÎÎÎÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq> ÎÎÎ ÎÎÎÏÎÎ ÏÎÏ "
+"ÎÏÎÏÎÎÎÎÏ."
+
+#: C/image-viewer.vala.page:276(p)
+msgid ""
+"If you haven't already done so, choose the <file>src/image-viewer</file> "
+"application in the dialog that appears. Finally, hit <gui>Run</gui> and "
+"enjoy!"
+msgstr ""
+"ÎÎÎ ÎÎÎ ÏÎ ÎÏÎÏÎ ÎÎÎ ÎÎÎÎÎ, ÎÏÎÎÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ <file>src/image-"
+"viewer</file> ÏÏÎÎ ÎÎÎÎÎÎÎ ÏÎÏ ÎÎÏÎÎÎÎÎÏÎÎ. ÎÎÎÎÎÎ, ÏÎÏÎÏÏÎ "
+"<gui>ÏÏÎÎÎÎÎ</gui> ÎÎÎ ÎÏÎÎÎÏÏÏÎ ÏÎ!"
+
+#: C/image-viewer.vala.page:282(p)
+#| msgid ""
+#| "If you run into problems with the tutorial, compare your code with this "
+#| "<link href=\"image-viewer/image-viewer.py\">reference code</link>."
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"image-viewer/image-viewer.vala\">reference code</link>."
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ "
+"ÏÎÎ <link href=\"image-viewer/image-viewer.vala\">ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+
+#: C/image-viewer.vala.page:286(title) C/image-viewer.py.page:230(title)
+#: C/image-viewer.js.page:316(title) C/image-viewer.cpp.page:215(title)
+#: C/image-viewer.c.page:226(title) C/guitar-tuner.vala.page:264(title)
+#: C/guitar-tuner.py.page:233(title) C/guitar-tuner.cpp.page:268(title)
+#: C/guitar-tuner.c.page:261(title)
+msgid "Next steps"
+msgstr "ÎÏÏÎÎÎÎ ÎÎÎÎÏÎ"
+
+#: C/image-viewer.vala.page:287(p) C/image-viewer.py.page:231(p)
+#: C/image-viewer.js.page:317(p) C/image-viewer.cpp.page:216(p)
+#: C/image-viewer.c.page:227(p) C/guitar-tuner.vala.page:265(p)
+#: C/guitar-tuner.py.page:234(p) C/guitar-tuner.cpp.page:269(p)
+#: C/guitar-tuner.c.page:262(p)
+msgid "Here are some ideas for how you can extend this simple demonstration:"
+msgstr ""
+"ÎÎÏ ÎÎÎÎÎ ÎÎÏÎÎÎÏ ÎÎÎÎÏ ÎÎÎ ÏÎ ÏÏÏ ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÏÎÎÎÎÏÎ ÎÏÏÎ ÏÎÎ ÎÏÎÎ "
+"ÏÎÏÎÏÏÎÎÏÎ:"
+
+#: C/image-viewer.vala.page:289(p)
+msgid ""
+"Set it up so that when the window opens it is of a specific size to start "
+"off with. For example, 200 X 200 pixels."
+msgstr ""
+"ÎÎÎÎÏÎÏÏÎÏÏÎ ÏÎÎ ÎÏÏÎ ÏÏÏÎ ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÎÎ ÎÎ ÎÎÎÎÎ ÏÏÎÎÎÎÏÎÎÎÎÎÏ "
+"ÎÎÎÎÎÎÏÏ ÎÎÎ ÎÎÎÎÎÎÏÎ. ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, 200 Î 200 ÎÎÎÎÎÎÏÏÎÎÏÎÎÎ."
+
+#: C/image-viewer.vala.page:291(p) C/image-viewer.py.page:234(p)
+#: C/image-viewer.js.page:320(p) C/image-viewer.cpp.page:219(p)
+#: C/image-viewer.c.page:230(p)
+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 ""
+"ÎÎÎÏÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎÏÎÎÎÎÎ ÎÎÏÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎ ÎÏÏÏÎ ÎÎÎÎÏÎÏÏ "
+"ÎÎ ÎÏÏÎÎÎÏÎ ÏÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ ÏÎ ÎÎÎÎ ÎÎÏÎÎÎÎÎ."
+
+#: C/image-viewer.vala.page:294(p) C/image-viewer.py.page:237(p)
+#: C/image-viewer.js.page:323(p) C/image-viewer.cpp.page:222(p)
+#: C/image-viewer.c.page:233(p)
+msgid ""
+"Apply random filters and effects to the image when it is loaded and allow "
+"the user to save the modified image."
+msgstr ""
+"ÎÏÎÏÎÏÏÏÎ ÏÏÏÎÎÎ ÏÎÎÏÏÎ ÎÎÎ ÎÏÎ ÏÏÎÎ ÎÎÎÏÎÎ ÏÏÎÎ ÎÏÏÎ ÏÎÏÏÏÎÎÎ ÎÎÎ ÎÏÎÏÏÎÏÏÎ "
+"ÏÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÏÎÎÎÎÎÏÏÎÎ ÏÎÎ ÎÏÎÎÎÏÎÎÏÎÎÎÎ ÎÎÎÏÎÎ."
+
+#: C/image-viewer.vala.page:295(p) C/image-viewer.py.page:238(p)
+#: C/image-viewer.js.page:324(p) C/image-viewer.cpp.page:223(p)
+#: C/image-viewer.c.page:234(p)
+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> ÏÎÏÎÏÎÎ ÎÏÏÏÏÎÏ "
+"ÎÏÎÎÏÏÏÎÏÎÏ ÎÏÎÎÎÏÎÎÏÎÎÏ ÎÎÎÏÎÎÏ."
+
+#: C/image-viewer.vala.page:298(p) C/image-viewer.py.page:241(p)
+#: C/image-viewer.js.page:327(p) C/image-viewer.cpp.page:226(p)
+#: C/image-viewer.c.page:237(p)
+msgid ""
+"Allow the user to load images from network shares, scanners, and other more "
+"complicated sources."
+msgstr ""
+"ÎÏÎÏÏÎÏÏÎ ÏÏÎÎ ÏÏÎÏÏÎ ÎÎ ÏÎÏÏÏÎÎÎ ÎÎÎÏÎÎÏ ÎÏÏ ÎÎÏÎÏÎÏ ÎÎÎÏÏÎÏ, ÎÏÏ ÏÎÏÏÏÎÏ "
+"ÎÎÎ ÎÏÏ ÎÎÎÎÏ ÏÎÏÎÏÎÎÎÎÏ ÏÎÎÎÏ."
+
+#: C/image-viewer.vala.page:299(p) C/image-viewer.py.page:242(p)
+#: C/image-viewer.js.page:328(p) C/image-viewer.cpp.page:227(p)
+#: C/image-viewer.c.page:238(p)
+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</link> ÎÎÎ ÏÎÎÏÎÏÎÏ ÏÎÏÏÏÎÏ."
+
+#: C/image-viewer.py.page:10(desc)
+msgid ""
+"A little bit more than a simple \"Hello world\" application - write an image "
+"viewer in GTK."
+msgstr ""
+"ÎÎÎ ÎÎÎÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÏÏ ÎÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÎ ÏÎ \"ÎÎÎÎ ÏÎÏ ÎÏÏÎÎ\" - ÎÏÎÏÏÎ ÎÎÎÎ "
+"ÏÏÎÎÎÎÎÎ ÎÎÎÏÎÏÎ ÏÎ GTK."
+
+#: C/image-viewer.py.page:14(name) C/image-viewer.js.page:14(name)
+msgid "Jonh Wendell"
+msgstr "Jonh Wendell"
+
+#: C/image-viewer.py.page:15(email) C/image-viewer.js.page:15(email)
+msgid "jwendell gnome org"
+msgstr "jwendell gnome org"
+
+#: C/image-viewer.py.page:27(p) C/image-viewer.js.page:27(p)
+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 ÏÎÏ ÏÎÏÏÏÎÎÎ "
+"ÎÎÎ ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ. ÎÎ ÎÎÎÎÏÎ ÏÏÏ ÎÎ:"
+
+#: C/image-viewer.py.page:29(p)
+msgid "Write a basic GTK user interface in Python"
+msgstr "ÎÏÎÏÎÏÎ ÎÎÎ ÎÎÏÎÎÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ GTK ÏÎ Python"
+
+#: C/image-viewer.py.page:30(p) C/image-viewer.js.page:30(p)
+msgid "Deal with events by connecting signals to signal handlers"
+msgstr "ÎÎ ÎÎÏÎÎÎÏÏÏÎÎÎÏÎ ÏÏÎÎÎÎÏÎ ÏÏÎÎÎÎÎÏÎÏ ÏÎÎÎÏÎ ÎÎ ÏÎÏÏ ÏÎÎÏÎÏÏÎÏ ÏÎÎÎÏÏÎ"
+
+#: C/image-viewer.py.page:31(p) C/image-viewer.js.page:31(p)
+msgid "Lay out GTK user interfaces using containers"
+msgstr "ÎÏÎÎÎÎÏÎÏ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ GTK ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÏÎÎÎÏÎÏ"
+
+#: C/image-viewer.py.page:32(p) C/image-viewer.js.page:32(p)
+msgid "Load and display image files"
+msgstr "ÎÏÏÏÏÏÎ ÎÎÎ ÎÎÏÎÎÎÏÎ ÎÏÏÎÎÏÎ ÎÎÎÏÎÏÎ"
+
+#: C/image-viewer.py.page:37(p)
+msgid "Basic knowledge of the python programming language"
+msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Python"
+
+#: C/image-viewer.py.page:51(p)
+#| 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."
+msgid ""
+"Choose <gui>PyGTK (automake)</gui> from the <gui>Python</gui> tab, click "
+"<gui>Continue</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>ÏÏÎÎÏÎÎÎ</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ "
+"ÎÏÏÎÎÎÎÏ ÎÎÎÎÏ ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ <file>image-viewer</file> ÏÏ ÏÎÎÎÎ "
+"ÏÎÏ ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÎÎÏÎÎÏÎÎÏ."
+
+#: C/image-viewer.py.page:54(p)
+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>ÏÏÎÏÎ ÏÎÏ GtkBuilder ÎÎÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎÏÎ</gui> ÎÏÎÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÏÎÎÏÎÎÎÎÎÏÎ ÏÎ ÎÏÏÏ ÏÎ "
+"ÏÎÏÎÎÎÎÎÎÎ. ÎÎÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÏ ÏÎÏ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ, ÎÎÎÏÎ ÏÎ <link "
+"xref=\"guitar-tuner.py\">ÎÏÎÎÎÎÎÎ ÏÏÎÎÎÏÏÎ ÎÎÎÎÏÎÏ</link>."
+
+#: C/image-viewer.py.page:59(p)
+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>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÎÏÎÏ. ÎÎÎÎÎÏÎ ÏÎ "
+"<file>src/image_viewer.py</file> ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ <gui>ÎÏÎÎ</gui> Î "
+"<gui>ÎÏÏÎÎÎ</gui>. ÎÎÏÎÎÎÎÎÎÎÎÎ ÏÎÎÏ ÎÎÏÎÎÏ ÏÎÏÎÎÎÎÎÎÎ ÎÏÎÎÎÎ."
+
+#: C/image-viewer.py.page:65(title) C/image-viewer.js.page:126(title)
+msgid "A first Gtk application"
+msgstr "ÎÎÎ ÏÏÏÏÎ ÎÏÎÏÎÎÎÎ ÏÎ Gtk"
+
+#: C/image-viewer.py.page:66(p)
+msgid "Let's see what a very basic Gtk application looks like in Python:"
+msgstr "ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÏÏ ÏÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎÏ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎÎ Gtk ÏÎ Python:"
+
+#: C/image-viewer.py.page:90(p) C/image-viewer.js.page:137(p)
+msgid "Let's take a look at what's happening:"
+msgstr "ÎÏ ÏÎÎÎÏÎÎ ÎÎÎ ÎÎÏÎÎ ÏÏÎ ÏÎ ÎÎÎÎÏÎÎ:"
+
+#: C/image-viewer.py.page:93(p) C/image-viewer.js.page:140(p)
+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 (ÎÏÏÏ ÎÎÎÎÎ ÏÎÏ ÏÎÏÎÎÏÎÎ ÏÎÎ "
+"ÎÎÎÎÎÎÎÎÎÎ ÏÎÏ Gtk). ÎÎ ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏÎÏÎÎÏÎÎ ÎÏÏ ÏÎ GObject Introspection "
+"(gi), ÏÎÏ ÏÎÏÎÏÎÎ ÎÎÏÏÏÎÎÎÏ ÎÎÏÎÎÏÏÎÎÏ ÎÎÎ ÏÎÎÎÎÏ ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏ GNOME."
+
+#: C/image-viewer.py.page:96(p)
+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>, ÎÏÎÏÏÎ ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎ ÎÎÏÎ ÏÏÎÎÎÏÏÎ "
+"ÎÎÎ ÏÎÎÎ ÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÏÎÎ. ÎÎÎÎÎ ÏÎÎÏ "
+"ÎÏÎÏ, ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎ ÏÎ ÏÎÎÎÏÎ ÎÏÎÏÏÎÏÎ."
+
+#: C/image-viewer.py.page:101(p)
+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> ÏÎÏ ÏÏÎÎÎÏÎÏÎ ÏÎÏÎÏÎÎÏ."
+
+#: C/image-viewer.py.page:105(p)
+msgid "The rest of the file does initialisation for Gtk and displays the GUI."
+msgstr ""
+"ÎÎ ÏÏÏÎÎÎÏÎ ÏÎÏ ÎÏÏÎÎÎÏ ÎÎÎÎÎ ÎÏÏÎÎÎÏÎÎÎÏÎ ÎÎÎ ÏÎ Gtk ÎÎÎ ÎÎÏÎÎÎÎÎÎ ÏÎ GUI."
+
+#: C/image-viewer.py.page:109(p)
+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>ÏÏÎÎÎÎÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq>. ÎÎ ÏÏÎÏÎÎ ÎÎ "
+"ÎÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎÎÎÎ ÏÎÏÎÎÏÏÎ."
+
+#: C/image-viewer.py.page:114(title) C/image-viewer.js.page:181(title)
+msgid "Signals"
+msgstr "ÎÎÎÎÏÎ"
+
+#: C/image-viewer.py.page:115(p) C/image-viewer.js.page:182(p)
+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>. ÎÎÎ ÎÎÎÎÏÎ "
+"ÏÎ ÏÏÏÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÎÎÎÎ ÎÎÏÎ ÏÏÎÎ ÎÏÏÏ ÏÏÎÎÎÎÎÎÎ, ÏÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎ "
+"ÏÏÎÎÏÏÎÏÎ (ÎÎÎÎ \"ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ\") ÏÎ ÎÏÏÏ ÏÎ ÏÎÎÎ. ÎÏÎÏÏÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ:"
+
+#: C/image-viewer.py.page:122(p) C/image-viewer.js.page:189(p)
+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> "
+"ÎÎ ÎÎÏÎÎÎÎÏÎÎ. ÎÎÏ ÎÏÎÎ ÏÏÏÏÎÎÎ ÎÎÎ ÎÎÎÏÎÎ."
+
+#: C/image-viewer.py.page:126(title) C/image-viewer.js.page:212(title)
+msgid "Containers: Laying-out the user interface"
+msgstr "ÎÎÏÎÎÎÏÎÏ: ÎÏÎÎÎÎÏÎ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ"
+
+#: C/image-viewer.py.page:127(p) C/image-viewer.js.page:213(p)
+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 ""
+"ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (ÎÎÎÎÏÎÎ, ÏÏÏÏ ÏÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎ ÎÏÎÎÎÏÎÏ) ÎÏÎÏÎÏÎ ÎÎ "
+"ÏÎÏÎÎÎÏÎÎÎÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÏÎÏ ÏÏÎÏÎ ÏÏÎ <em>ÏÎÏÎÎÎÏÏÎ</em>. ÎÏÎÏÎÎÏÎ ÎÎ "
+"ÎÏÎÎÎÏÏÎÏÎ ÏÎÎ ÎÎÎÏÎÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏ ÎÎÎÏÎÏÎÏÎÎÏÎ ÎÎÎÏÎ ÏÎÏÎÎÎÏÎÏ, ÏÏÏÏ "
+"ÏÎÎÎÏÎÎ ÎÎÎ ÏÎÎÎÎÎÏÎ."
+
+#: C/image-viewer.py.page:128(p) C/image-viewer.js.page:214(p)
+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> ÎÎÎÎÎ ÎÏÏ ÎÏÎÎ ÏÎÏ ÎÎÎ ÎÎÎÎÏ ÏÎÏÎÎÎÏÎ, ÎÎÎÎ "
+"ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎ ÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÎÎÏÎ ÏÎÎÏ ÏÎÏ. ÎÎ "
+"ÎÎÎÎÎÎ ÎÎ ÎÎÏÎÎÎ ÎÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ, ÎÎÎ ÎÎÎÏÎÎ ÎÎÎ ÎÎÎ ÎÎÏÎÏÎ, ÎÏÎ ÎÎ "
+"ÏÏÎÏÎÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÎÎÎÎ ÏÏÎÎÎÏÎÎ \"ÏÏÎÎÏÏÎÏÎÏ ÏÏÏÎÏÎÎÏÏÎÏÎÏ\" ÎÎÏÎ ÏÏÎ "
+"ÏÎÏÎÎÏÏÎ ÎÎÎ ÎÎ ÎÏÎÏÎÎÎ ÏÎ ÎÎÎÎ ÎÏÎÏÎÎÎ ÏÏÎÎÏÎÎÎ. ÎÎÎÏ ÎÏÎÎÎÏÏ ÎÏÏ <link "
+"href=\"http://library.gnome.org/devel/gtk/stable/GtkContainer.html\";>ÏÏÏÎÏÏ "
+"ÏÎÏÎÎÎÏÏÎ</link> ÎÎÎÎÎ ÎÎÎÎÎÏÎÎÎÎ, ÎÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÏ ÎÎÎ "
+"<code>Gtk.Box</code>. ÎÎÎ <code>Gtk.Box</code> ÎÏÎÏÎÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎÎÎÎ "
+"ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ, ÎÏÎÎÎÏÎÎÎÎ ÎÏÎÎÏÎÏÎÎ Î ÎÎÎÎÏÎ. ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎÏÎ ÎÎÎ ÏÎÎ "
+"ÏÎÏÎÏÎÎÎÎÏ ÎÎÎÏÎÎÎÎÏ ÎÎÎÎÎÏÎÏ ÏÎÎÎÎ ÏÎÎÎÏÎÎ ÏÎ ÎÎÎ ÎÎÏÎ ÏÏÎ ÎÎÎÎ Î.Î.Î."
+
+#: C/image-viewer.py.page:130(p) C/image-viewer.js.page:216(p)
+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> ÏÎÏ ÎÎÎÎÎ ÏÎ ÏÏÎÎÎÎÏÎ ÎÏÎÏÎÎÎÏ "
+"ÏÎÏÎÎÎÎÎÎÎÏÎÏ ÏÎÎÏ ÎÏÎÎÎÎ. ÎÎÎ ÎÏÏÏ ÏÎ ÎÏÎÏ ÏÎÏÎÎÎÎÎÎÎ, ÏÎÏÏ, ÎÎ "
+"ÎÏÎÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎ ÏÎÎÏÎ ÏÎÎÏÎÎÎÎÎÏÎ."
+
+#: C/image-viewer.py.page:132(p)
+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 ""
+"ÎÏ ÏÏÎÏÎÎÏÎÏÎÎ ÎÎÎ ÏÎÎÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎÏÎÎÏÏÎ ÏÎÎ "
+"ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎ ÏÏÎ ÎÎÎÎÎÎ <code>__init__</code>, ÎÎÎÏÏÏ ÎÎÏÎ ÏÎ ÎÏÎÎÎÎ "
+"<code>window.connect_after</code>:"
+
+#: C/image-viewer.py.page:140(p)
+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> ÏÏÎÎÎÎÎÏÎÎ ÏÎ ÎÎÎÎÏÎ (ÎÏÏÏÎ ÏÎ ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎ) ÎÎÎ ÏÎ <code>spacing</code> ÎÎÎÎÎÏÎ ÏÏÎ "
+"ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÏÎÎ ÏÏÎÎÎÏÏÎÎ ÏÏÎ 5 ÎÎÎÎÎÎÏÏÎÎÏÎÎÎ. Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ "
+"ÎÏÎÎÏÎ ÏÏÎÏÎÎÏÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÏÎ ÎÎÎÎÎÎÎÎÏÏÎÎÎÎÎÎ <code>Gtk.Box</code>."
+
+#: C/image-viewer.py.page:141(p) C/image-viewer.js.page:223(p)
+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> ÎÎÎÎÎ ÎÎÎÏ ÎÎÎÏÎÎÎÏ ÏÎÏÎÎÎÏÎÏ, ÎÏÏÏÎ ÎÎÎ ÎÏÎÏÎÎÏÎ ÎÎ "
+"ÎÎÎÏÎ ÏÏÎ ÎÎÎÎÎ ÎÎÎÎ)."
+
+#: C/image-viewer.py.page:145(title) C/image-viewer.js.page:227(title)
+msgid "Packing: Adding widgets to the container"
+msgstr "ÎÏÏÎÎÏÎÏÎÎ: ÎÏÏÏÎÎÏÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ ÏÏÎÎ ÏÎÏÎÎÎÏÎ"
+
+#: C/image-viewer.py.page:146(p)
+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 ""
+"ÎÎÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÏÎ <code>Gtk.Box</code>, "
+"ÎÎÏÎÎÎÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÎÎÎ ÎÎÏÎÎÏÏ ÎÎÏÏ ÎÏÏ ÏÎÎ ÎÏÎÎÎÎ <code>window.add "
+"(box)</code>:"
+
+#: C/image-viewer.py.page:150(p)
+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>, ÏÎÏ ÎÎ ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ. ÎÎÎÏÏ ÏÎ "
+"ÏÏÎÎÎÎÏÎÎÏÏÎ ÎÏÎÏÏÎÏÎ ÏÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ, ÎÎ ÏÎ ÎÏÎÏÎÏÎÎ ÏÏ ÎÎÏÎÎÎÎÏÎ "
+"ÎÏÏÎÎÎÏ ÎÎÎÏÎÏ. ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÏÎ <code>image = 0</code> ÏÏÎÎ ÎÏÏÎ ÏÎÏ "
+"ÎÎÎÏÎÏ <code>GUI</code>. ÎÏÎÎÏÎ, ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ "
+"ÏÏÎÏÏÎÎÎÏÎÎ (<em>ÏÎÎÎÏÎÏÎÏÎÎ</em>) ÏÏÎÎ ÏÎÏÎÎÎÏÎ <code>box</code> "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÎÎÎÎÎÎ <link "
+"href=\"http://library.gnome.org/devel/gtk/stable/GtkBox.html#gtk-box-pack-";
+"start\"><code>pack_start</code></link> ÏÎÏ GtkBox."
+
+#: C/image-viewer.py.page:152(p)
+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 ÏÎÏÎÎÎÏÏÎÏÏ: ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ "
+"ÎÎ ÏÏÎÏÏÎÎÎÎ ÏÏÎ 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>)."
+
+#: C/image-viewer.py.page:153(p) C/image-viewer.js.page:234(p)
+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 ""
+"ÎÎ ÏÎÏÎÎÎÏÎÏ (ÎÎÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ) ÏÎÏ Gtk ÎÏÎÎÏÎÎÎÎÎÏÎÎ ÎÏÎÎÎÎÎÎ ÎÎÎ "
+"ÎÎ ÎÎÎÏÏÎÏÎ ÏÎÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ, ÎÎ ÏÎ ÎÏÎÏÎÏÎ. ÎÎÎ ÏÎÏÎÎÎÏÎÎÏÎ ÏÎ ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ ÎÎÎÎÎÏÎÏ ÏÎÏÏ ÎÎÏÎÎÎÎÏ ÎÎÏÎÎÏ x, y-ÏÏÎÏÎÏÎÎÎÎÎÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎÂ "
+"ÎÎÎÎ, ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÏÏÎÏÎÎÎ ÎÎÏÎÎÏ ÏÎÏÏ. ÎÏÏÏ ÎÎÎÎÎ ÏÎ ÏÎÎÏÎÏÎÏ ÏÎÏ ÎÎÎÎÎÎÏ "
+"ÏÎÏ ÎÎÎÎÎÎÏÏ ÏÎÏ ÏÎÏÎÎÏÏÎÏ ÏÎÎ ÎÏÎÎÎÎ ÎÎÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÏÎÏÎÎ ÎÎ "
+"ÏÎÏÎÏÎ ÎÏÏÏÎÎÏÎ ÎÎÎ ÎÎÎÎÎÏ ÎÎÎÎÎÎÏ ÏÏÎÏ ÏÎÏÎÏÏÏÏÎÏÎÏ ÏÎÏÎÏÏÏÏÎÎÏ."
+
+#: C/image-viewer.py.page:154(p) C/image-viewer.js.page:235(p)
+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 ""
+"ÎÏÎÏÎÏ ÏÎÎÎÎÏÏÏÎ ÏÏÏ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÎÎÎ ÎÎÏÎÏÏÎÎ. "
+"ÎÏÎÎÏ ÏÎÎÎÏÎÏÎÏÏÎÏÎ ÎÎÏÎ ÏÏÎ <code>Gtk.Box</code>, ÏÎ <code>Gtk.Image</code> "
+"ÎÎÏÏÎÎÏÎÎ <em>ÎÎÏÎÏÎ</em> ÏÎÏ <code>Gtk.Box</code>. ÎÏÏÏ ÎÏÎÏÏÎÏÎÎ ÎÎ "
+"ÏÏÎÏÎÏÎÏÎÏÎÎÏÎÎ ÏÎ ÏÎÎ ÏÎ ÎÎÏÎÏÎÏÎ ÎÎÏÏ ÎÏÎÏÎÎÎÏ ÏÏÎÎÏÎÎÎÏ ÏÏ ÎÎÎ ÎÎÎÎÎÂ ÎÎÎ "
+"ÏÎÏÎÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÏÏÎÏÎ ÏÎ <code>Gtk.Box</code>, ÏÎÏ ÎÎ ÎÏÏÏÎÎ "
+"ÎÏÎÏÎÏ ÏÎÎ ÏÎ ÎÎÏÎÏÎÏÎ ÏÎÏ ÏÎÏÏÏÏÏÎÎÎ."
+
+#: C/image-viewer.py.page:155(p) C/image-viewer.js.page:236(p)
+msgid "Now insert these two lines, below the two you just added:"
+msgstr ""
+"ÎÏÏÎ ÏÏÎÏÎÎÏÏÎ ÎÏÏÎÏ ÏÎÏ ÎÏÎ ÎÏÎÎÎÎÏ, ÎÎÏÏ ÎÏÏ ÎÏÏÎÏ ÏÎÏ ÎÏÎÎÏ ÏÏÎÏÎÎÏÎÏÎ:"
+
+#: C/image-viewer.py.page:160(p)
+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>. ÎÏÏÎ Î ÎÎÎÏÎÎ ÎÎ ÏÎÏÎÎ ÏÎÎ "
+"ÏÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÏÎÎ ÎÏÎÎ ÏÏÎ ÏÏÎÎÎÎÎÎÏÎÎ. ÎÏÎÎ ÎÎÎÎÏÏÎÏÎÎÎÏÎÎÏ "
+"ÏÎ ÏÎÏÎÎÏÏÎ, ÏÎ ÎÎÎÎÎÎÏ ÏÏÎ ÎÎÏÎÏÎÏÎ ÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎ ÎÎÎÎ, ÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ "
+"ÎÎ ÎÏÎÎÎÎÎ, ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ ÏÎ ÏÏÏÎÎÎÏÎ ÏÎÏÎÎÏÏÎ."
+
+#: C/image-viewer.py.page:164(title) C/image-viewer.js.page:247(title)
+msgid ""
+"Loading the image: Connecting to the button's <code>clicked</code> signal"
+msgstr ""
+"ÎÏÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÎÏ: ÎÏÎÎÎÏÎ ÏÏÎ ÏÎÎÎ ÏÎÏ ÎÎÏÎÏÎÎÏ <code>clicked</code>"
+
+#: C/image-viewer.py.page:165(p)
+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>ÎÎÎÎÎÎÎ ÎÎÎÏÎÎÏâ</gui>, ÎÎÎÏ "
+"ÎÎÎÎÎÎÎÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÏÏÎ Î ÏÏÎÏÏÎÏ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ. ÎÏÎÎÏ "
+"ÎÎÎÎÎÎÎÎ, Î ÎÎÎÏÎÎ ÎÎ ÏÎÏÏÏÎÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÏÎ ÎÎÏÎÏÏÎÎÏÎ ÎÏÎÏÎÎÏ "
+"ÏÏÏÏÎÏÎÎÏ."
+
+#: C/image-viewer.py.page:166(p)
+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>:"
+
+#: C/image-viewer.py.page:170(p)
+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> Î ÎÏÎÎÎ ÎÎ ÎÏÎÏÏÎÎ ÏÎÏÎÎÎÏÏ."
+
+#: C/image-viewer.py.page:175(title) C/image-viewer.js.page:257(title)
+msgid "Loading the image: Writing the signal's callback"
+msgstr "ÎÏÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÎÏ: ÎÏÎÏÎÎÏÎÏ ÏÎÎ ÎÏÎÎÎÎÎÎÏÎ (callback) ÏÎÏ ÏÎÎÎÏÎÏ"
+
+#: C/image-viewer.py.page:176(p)
+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>:"
+
+#: C/image-viewer.py.page:192(p) C/image-viewer.js.page:278(p)
+#: C/image-viewer.cpp.page:172(p) C/image-viewer.c.page:185(p)
+msgid ""
+"This is a bit more complicated than anything we've attempted so far, so "
+"let's break it down:"
+msgstr ""
+"ÎÏÏÏ ÎÎÎÎÎ ÎÎÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎ ÎÏÏ ÏÏÎ ÎÏÎÏÎÎ ÎÎÎÎÎ ÎÎÏÏÎ ÏÏÏÎ, ÎÎÎ ÎÏÏÏ ÎÎ "
+"ÏÎ ÏÏÏÎÏÎÏÎÎ ÏÎ ÎÎÎÎÎÏÎÎ:"
+
+#: C/image-viewer.py.page:195(p)
+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>, ÏÏÎÏ ÎÏÎÎÎÎ ÏÎ ÎÎÎÎÎÏ ÏÎÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ."
+
+#: C/image-viewer.py.page:198(p) C/image-viewer.js.page:284(p)
+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>ÎÎÏÏÏÏÎ</gui> ÎÎÎ 1 ÎÎÎ ÏÎ <gui>ÎÎÎÎÎÎÎ</gui>."
+
+#: C/image-viewer.py.page:199(p) C/image-viewer.js.page:285(p)
+#: C/image-viewer.cpp.page:180(p) C/image-viewer.c.page:197(p)
+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 ""
+"ÎÎÎÎÎÏÏÏÎ ÏÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ <em>ÏÏÎÎÎÎÎÏÎÏÎÎÎÎ</em> ÎÎÏÎÎÏÎ ÎÎÏÎÏÎÏÎ "
+"ÏÎÏ ÏÏÎÏÏÎÏÎ ÏÏÎ Gtk, ÎÎÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÂÎÎÏÏÏÏÎÂ Î ÂÎÎÎÎÎÎÎÂ. ÎÎ "
+"ÏÎÎÎÎÎÎÏÎÎÎ ÏÏÎ ÏÏÎÏÎ ÏÏÎ ÏÏÎÎÎÎÎÏÎÏÎÎÎÏÎ ÎÎÎÎÎÏÏÎ ÎÎÎÎÎ ÏÏÎ ÎÎ ÎÏÎÎÎÏÎÏ ÏÏÎ "
+"ÎÎÏÎÏÎÏÎ ÎÎ ÎÏÎÏÎ ÎÎÎ ÎÎÏÎÏÏÎÏÏÎÎ ÏÏÎ ÎÎÏÏÏÎ ÏÎÏ ÏÏÎÏÏÎ."
+
+#: C/image-viewer.py.page:202(p) C/image-viewer.js.page:288(p)
+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>ÎÎÎÎÎÎÎ</gui> ÏÎÎ "
+"ÏÏÎÎÏÎÎÎÎÎÎÎÎ (ÏÎ ÎÏÎÎÎ ÎÏÎÎ ÏÎÎÎ 1)."
+
+#: C/image-viewer.py.page:205(p) C/image-viewer.js.page:291(p)
+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>ÎÎÎÎÎÎÎ</gui> ÎÎ "
+"ÎÎÏÎÎÎÎÎÎ ÎÏÎÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÏÎÎÏÎ ÎÏÏ ÏÎ "
+"<code>Gtk.Image</code>. ÎÎÎÎÎÏÏÎÎÏÎÎ ÏÏÏÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ ÏÎÎÏÏÎÏÂ "
+"ÏÏÎÏÎÎÏÎÏÎÎ ÏÏÎ ÏÎÎÏÏÎ ÏÎÏÎ ÏÏÎ ÎÎÎÏÎ ÎÏÏÎÎÎ ÏÎÏ ÏÏÎÏÏÎÏÎÎÎÎÏÎÎ ÎÏÏ ÏÎ "
+"<code>Gdk.Pixbuf</code> (ÏÎ ÎÏÎÎÎ ÏÎÏÎÎÏÎÎ ÏÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎÎ ÎÎÎÏÎÏÎ ÏÏÏÏ "
+"PNG ÎÎÎ JPEG). ÎÎÎÎÏ, ÎÎÎÎÏÎÎÎÏÎÎ ÏÎ ÏÎÎÏÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ "
+"<gui>ÎÎÎÎÎÎÎ</gui>."
+
+#: C/image-viewer.py.page:208(p)
+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>ÎÎÎÎÎÎÎ</gui>. Î "
+"ÎÎÎÎÎÎÎÏ ÎÎ ÏÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎÂ ÏÏÎÎ ÎÎÎÎÎÎÎÎ, ÏÎ "
+"<code>dialog.run</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÎÎ ÏÎÎÎ <output>1</output> (ÎÎ "
+"ÎÏÎÏÏÏÎÏÎÎ <output>0</output> ÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎÎ <gui>ÎÎÏÏÏÏÎ</gui>). Î "
+"ÎÎÎÎÏÎÏ ÏÎÎÏ <code>if</code> ÎÎÎÎÏÎÎ ÎÎÎ ÎÏÏÏ."
+
+#: C/image-viewer.py.page:210(p) C/image-viewer.js.page:296(p)
+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>ÎÎÎÎÎÎÎ</gui>, Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ "
+"ÎÏÎÎÎÎ ÏÎÎ ÎÎÎÏÏÎÏÎ <code>file</code> ÏÎÏ <code>Gtk.Image</code> ÏÏÎ ÏÎÎÎÎ "
+"ÏÎÏ ÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎÎ Î ÏÏÎÏÏÎÏ. ÎÎ <code>Gtk.Image</code> ÎÎ "
+"ÏÎÏÏÏÏÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎÎ ÎÏÎÎÎÎÎÎÎÎ ÎÎÎÏÎÎ."
+
+#: C/image-viewer.py.page:221(p)
+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) ÏÎ ÎÎÎÏÎÏÏÎ "
+"ÏÏÏÎÎ!"
+
+#: C/image-viewer.py.page:226(p)
+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\">ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+
+#: C/image-viewer.js.page:10(desc)
+#| msgid ""
+#| "A little bit more than a simple \"Hello world\" application - write an "
+#| "image viewer in GTK."
+msgid ""
+"A little bit more than a simple \"Hello world\" application - write an image "
+"viewer in GTK. Includes an introduction to the JavaScript language."
+msgstr ""
+"ÎÎÎ ÎÎÎÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÏÏ ÎÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÎ ÏÎ \"Hello world\"- ÏÏÎÎÏÎÏÎ ÎÎÏÏ "
+"ÏÏÎÎÎÎÎÎ ÎÎÎÏÎÏÎ ÏÎ GTK. ÎÎÏÎÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÏÎÎÏÎÎ ÏÏÎ ÎÎÏÏÏÎ JavaScript."
+
+#: C/image-viewer.js.page:29(p)
+#| msgid "Write a basic GTK user interface in Python"
+msgid "Write a basic GTK user interface in JavaScript"
+msgstr "ÎÏÎÏÎ ÎÎÎ ÎÎÏÎÎÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ GTK ÏÎ JavaScript"
+
+#: C/image-viewer.js.page:37(p)
+msgid "An installed copy of the <em>gjs</em> interpreter"
+msgstr "ÎÎÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÎÎÏÎÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÎÎÎÏÏÎ <em>gjs</em>"
+
+#: C/image-viewer.js.page:38(p)
+#| msgid "Basic knowledge of the python programming language"
+msgid "Basic knowledge of any object-orientated programming language"
+msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÎÏÎÎÎÏÎÎÏÎÏÎ ÎÎÏÎÎÎÎÎÎÎÎÏÏÏÎÏÎÏÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ"
+
+#: C/image-viewer.js.page:52(p)
+#| 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."
+msgid ""
+"Choose <gui>Generic Javascript</gui> from the <gui>JS</gui> tab, click "
+"<gui>Forward</gui>, and fill out your details on the next few pages. Use "
+"<file>image-viewer</file> as project name and directory."
+msgstr ""
+"ÎÏÎÎÎÎÏÎ <gui>ÎÎÎÎÎÎ Javascript</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>JS</gui>, ÏÎÏÎÏÏÎ "
+"<gui>ÎÏÏÎÏÏÎ</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
+"ÎÎÎÎÏ ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ <file>image-viewer</file> ÏÏ ÏÎÎÎÎ ÎÏÎÎÏ "
+"ÎÎÎ ÎÎÏÎÎÏÎÎÏ."
+
+#: C/image-viewer.js.page:55(p)
+#| 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."
+msgid ""
+"Click <gui>Apply</gui> and the project will be created for you. Open "
+"<file>src/main.js</file> from the <gui>Project</gui> or <gui>File</gui> "
+"tabs. It contains very basic example code."
+msgstr ""
+"ÎÎÏÎÏÏÎ <gui>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÎÏÎÏ. ÎÎÎÎÎÏÎ ÏÎ "
+"<file>src/main.js</file> ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ <gui>ÎÏÎÎ</gui> Î "
+"<gui>ÎÏÏÎÎÎ</gui>. ÎÎÏÎÎÎÎÎÎÎÎÎ ÏÎÎÏ ÎÎÏÎÎÏ ÏÎÏÎÎÎÎÎÎÎ ÎÏÎÎÎÎ."
+
+#: C/image-viewer.js.page:62(title)
+msgid "JavaScript basics: Hello World"
+msgstr "ÎÎÏÎÎÎ JavaScript: Hello World"
+
+#: C/image-viewer.js.page:63(p)
+msgid ""
+"Before we start writing the image viewer, let's find out more about the way "
+"JavaScript is used in GNOME. Of course, your very first contact with any "
+"programming language should be the Hello World program which can already be "
+"found in <file>main.js</file>:"
+msgstr ""
+"ÎÏÎÎ ÎÎ ÎÎÎÎÎÎÏÎÏÎÎ ÏÎÎ ÏÏÎÏÎÎÎ ÏÎÏ ÏÏÎÎÎÎÎÎ ÎÎÎÏÎÎÏ, ÎÏ ÎÎÎÏÎÏÎÏÎÎ "
+"ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎ ÏÎÎ ÏÏÏÏÎ ÏÏÎÏÎÏ ÏÎÏ JavaScript ÏÏÎ GNOME. ÎÏÏÎÎÎ, Î ÏÏÏÏÎ "
+"ÏÎÏ ÎÎ ÎÏÎÎÎÎÎÏÎÏÎ ÎÎÏÏÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÏÏÎÏÎÎÎÎ Hello "
+"World ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÎÏÎÎÎÎ ÎÎÎ ÏÏÎ <file>main.js</file>:"
+
+#: C/image-viewer.js.page:64(code)
+#, no-wrap
+msgid "print (\"Hello world!\");"
+msgstr "ÎÎÏÏÏÏÏÎ (\"Hello world!\")Â"
+
+#: C/image-viewer.js.page:65(p)
+msgid ""
+"This should look quite natural if you're familiar with almost any other "
+"programming language. The function <code>print</code> is called with the "
+"argument <code>\"Hello world!\"</code>, which will be printed on the screen. "
+"Note that each line of code ends with a semicolon."
+msgstr ""
+"ÎÏÏÏ ÎÎ ÏÎÎÎÎÏÎÎ ÎÎÏÏÎÎÎ ÏÏÏÎÎÏ, ÎÎÎ ÎÎÏÏÎ ÎÎÎÎÎÎÎÏÎÎÎÎÏ ÎÎ ÏÏÎÎÏÎ "
+"ÎÏÎÎÎÎÎÏÎÏÎ ÎÎÎÎ ÎÎÏÏÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ. Î ÏÏÎÎÏÏÎÏÎ <code>print</code> "
+"ÎÎÎÎÎÏÎÎ ÎÎ ÏÎ ÏÏÎÏÎÎ <code>\"Hello world!\"</code>, ÏÎÏ ÎÎ ÎÎÏÏÏÏÎÎÎ ÏÏÎÎ "
+"ÎÎÏÎÎ. ÎÎÎÎÎÏÏÏÎ ÏÏÎ ÎÎÎÎ ÎÏÎÎÎÎ ÎÏÎÎÎÎ ÏÎÎÎÎÏÎÎÎ ÎÎ ;."
+
+#: C/image-viewer.js.page:69(title)
+msgid "Classes in JavaScript"
+msgstr "ÎÎÎÏÎÎÏ ÏÏÎ JavaScript"
+
+#: C/image-viewer.js.page:70(p)
+msgid "This is the standard way to define a class in JavaScript:"
+msgstr "ÎÏÏÏÏ ÎÎÎÎÎ Î ÏÏÏÎÎÏÏ ÏÏÏÏÎÏ ÎÏÎÏÎÎÏ ÎÎÎÏ ÎÎÎÏÎÏ ÏÏÎ JavaScript:"
+
+#: C/image-viewer.js.page:93(p)
+msgid ""
+"This defines a class called <code>MyClass</code>. Let's go through each part "
+"of the class definition:"
+msgstr ""
+"ÎÏÏÏ ÎÏÎÎÎÎ ÎÎÎ ÎÎÎÏÎ ÏÎÏ ÎÎÎÎÏÎÎ <code>MyClass</code>. ÎÏ ÎÎÏÎÎ ÎÎÎÎ ÏÎÎÎÎ "
+"ÏÎÏ ÎÏÎÏÎÎÏ ÏÎÏ ÎÎÎÏÎÏ:"
+
+#: C/image-viewer.js.page:96(p)
+msgid ""
+"<code>function MyClass</code> is the constructor of the class â its name "
+"must match the class's name. You can access any member of the class by using "
+"the <code>this</code> object; here, the constructor calls the class's "
+"<code>_init</code> method."
+msgstr ""
+"<code>function MyClass</code> ÎÎÎÎÎ Î ÎÎÏÎÏÎÎÏÎÏÏÎÏ ÏÎÏ ÎÎÎÏÎÏ â ÏÎ ÏÎÎÎÎ "
+"ÏÎÏ ÏÏÎÏÎÎ ÎÎ ÏÎÎÏÎÎÎÎÎ ÎÎ ÏÎ ÏÎÎÎÎ ÏÎÏ ÎÎÎÏÎÏ. ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÏÎÎÎÏÎÏÎ "
+"ÎÏÎÎÎÎÎÏÎÏÎ ÎÎÎÎÏ ÏÎÏ ÎÎÎÏÎÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÎÎÏÎÎÎÎÎÎÎÎ "
+"<code>this</code>Â ÎÎÏ, Î ÎÎÏÎÏÎÎÏÎÏÏÎÏ ÎÎÎÎÎ ÏÎ ÎÎÎÎÎÎ ÏÎÏ ÎÎÎÏÎÏ "
+"<code>_init</code>."
+
+#: C/image-viewer.js.page:99(p)
+msgid ""
+"The <code>MyClass.prototype</code> block is where you define the "
+"<em>structure</em> of the class. Each class is made up of methods "
+"(functions) and fields (variables); there are three methods and two fields "
+"in this example."
+msgstr ""
+"Î ÎÎÎÎÎ <code>MyClass.prototype</code> ÎÎÎÎÎ ÎÎÎÎ ÏÎÏ ÎÏÎÎÎÏÎ ÏÎ "
+"<em>ÎÎÎÎ</em> ÏÎÏ ÎÎÎÏÎÏ. ÎÎÎÎ ÎÎÎÏÎ ÎÏÎÏÎÎÎÎÏÎÎ ÎÏÏ ÎÎÎÏÎÎÏÏ (ÏÏÎÎÏÏÎÏÎÎÏ) "
+"ÎÎÎ ÏÎÎÎÎ (ÎÎÏÎÎÎÎÏÎÏ)Â ÏÏÎÏÏÎÏÎ ÏÏÎÎÏ ÎÎÎÎÎÎÎ ÎÎÎ ÎÏÎ ÏÎÎÎÎ ÏÎ ÎÏÏÏ ÏÎ "
+"ÏÎÏÎÎÎÎÎÎÎ."
+
+#: C/image-viewer.js.page:102(p)
+msgid ""
+"The first method defined here is called <code>_init</code>, and we specify "
+"that it is a function with no arguments:"
+msgstr ""
+"Î ÏÏÏÏÎ ÎÎÎÎÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏÏÎÎÎ ÎÎÏ ÎÎÎÎÏÎÎ <code>_init</code> ÎÎÎ "
+"ÎÎÎÎÏÎÎÎÏÎÎ ÏÏÎ ÎÎÎÎÎ ÎÎÎ ÏÏÎÎÏÏÎÏÎ ÏÏÏÎÏ ÎÏÎÏÎÎÏÎ:"
+
+#: C/image-viewer.js.page:103(code)
+#, no-wrap
+msgid "_init: function ()"
+msgstr "_init: function ()"
+
+#: C/image-viewer.js.page:104(p)
+msgid ""
+"We write the function inside some curly braces. Two fields are defined here, "
+"<code>propertyA</code> and <code>propertyB</code>. The first is set to a "
+"string and the second is set to an integer (10). The function doesn't return "
+"any value."
+msgstr ""
+"ÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ ÎÎÏÎ ÏÎ ÎÎÏÎÎÎÏ ÎÎÎÏÎÎÏ. ÎÏÎ ÏÎÎÎÎ ÎÏÎÎÎÎÏÎÎ ÎÎÏ, "
+"<code>propertyA</code> ÎÎÎ <code>propertyB</code>. ÎÎ ÏÏÏÏÎ ÎÏÎÎÎÏÎÎ ÏÎ ÎÎÎ "
+"ÏÏÎÎÎÎÎÏÎÎÏÎ ÎÎÎ ÏÎ ÎÎÏÏÎÏÎ ÎÏÎÎÎÏÎÎ ÏÎ ÎÎÎÎ ÎÎÎÏÎÎÎ (10). Î ÏÏÎÎÏÏÎÏÎ ÎÎÎ "
+"ÎÏÎÏÏÏÎÏÎÎ ÎÎÎÎÎ ÏÎÎÎ."
+
+#: C/image-viewer.js.page:107(p)
+msgid ""
+"The next method is called <code>aMethod</code> and has two arguments, which "
+"it prints out when you call it. The final method is <code>dumpProperties</"
+"code>, and prints the fields <code>propertyA</code> and <code>propertyB</"
+"code>."
+msgstr ""
+"Î ÎÏÏÎÎÎÎ ÎÎÎÎÎÎÏ ÎÎÎÎÏÎÎ <code>aMethod</code> ÎÎÎ ÎÏÎÎ ÎÏÎ ÎÏÎÏÎÎÏÎ, ÏÎÏ "
+"ÎÎÏÏÏÏÎÎÏÎÎ ÏÏÎÎ ÏÎÎ ÎÎÎÎÎÏÎ. Î ÏÎÎÎÎÎ ÎÎÎÎÎÎÏ ÎÎÎÎÎ "
+"<code>dumpProperties</code> ÎÎÎ ÏÏÏÏÎÎÎ ÏÎ ÏÎÎÎÎ <code>propertyA</code> ÎÎÎ "
+"<code>propertyB</code>."
+
+#: C/image-viewer.js.page:110(p)
+msgid ""
+"Note how the class definition (prototype) is arranged; each function "
+"definition is separated by a comma."
+msgstr ""
+"ÎÎÎÎÎÏÏÏÎ ÏÏÏ ÏÎÎÏÎÏÎÎÎÎÏÎÎ Î ÎÏÎÏÎÏÏ ÎÎÎÏÎÏ (ÏÏÏÏÏÏÏÏÎ)Â ÎÎÎÎ ÎÏÎÏÎÏÏ "
+"ÏÏÎÎÏÏÎÏÎÏ ÎÎÏÏÏÎÎÎÏÎÎ ÎÎ ÎÏÎÎÎ."
+
+#: C/image-viewer.js.page:114(p)
+msgid "Now that MyClass has been defined, we can play with it:"
+msgstr "ÎÏÏÎ ÏÎÏ Î MyClass ÎÏÎÏÏÎÎÎ, ÎÏÎÏÎÏÎÎ ÎÎ ÏÎÎÎÎÏÎÎ ÎÎÎÎ ÏÎÏ:"
+
+#: C/image-viewer.js.page:120(p)
+msgid ""
+"This code creates a new instance of the class called <code>o</code>, runs "
+"<code>aMethod</code>, changes <code>propertyA</code> to a different string, "
+"and then calls <code>dumpProperties</code> (which outputs the fields)."
+msgstr ""
+"ÎÏÏÏÏ Î ÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÎ ÏÏÎÎÎÎÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÏ ÏÎÏ ÎÎÎÎÏÎÎ "
+"<code>o</code>, ÏÏÎÏÎÎ ÏÎ <code>aMethod</code>, ÎÎÎÎÎÎÎ ÏÎÎ "
+"<code>propertyA</code> ÏÎ ÎÎÎÏÎÏÎÏÎÎÎ ÏÏÎÎÎÎÎÏÎÎÏÎ ÎÎÎ ÎÏÎÎÏÎ ÎÎÎÎÎ "
+"<code>dumpProperties</code> (ÏÎÏ ÎÎÎÎÎÎ ÏÎ ÏÎÎÎÎ)."
+
+#: C/image-viewer.js.page:121(p)
+#| 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."
+msgid ""
+"Save the code in the <file>main.js</file> and then run it by using "
+"<guiseq><gui>Run</gui><gui>Execute</gui></guiseq> from the menu or using the "
+"toolbar."
+msgstr ""
+"ÎÏÎÎÎÎÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÏÎ <file>main.js</file> ÎÎÎ ÎÏÎÎÏÎ ÏÏÎÎÏÎ ÏÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ <guiseq><gui>ÏÏÎÎÎÎÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq> ÎÏÏ "
+"ÏÎ ÎÎÎÎÏ Î ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ ÎÏÎÎÎÎÎÎÎÎÎÎ."
+
+#: C/image-viewer.js.page:127(p)
+#| msgid "Let's see what a very basic Gtk application looks like in Python:"
+msgid "Let's see what a very basic Gtk application looks like in JavaScript:"
+msgstr "ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÏÏ ÎÎÎ ÏÎÎÏ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎÎ Gtk ÏÎÎÎÎÏÎÎ ÏÎ JavaScript:"
+
+#: C/image-viewer.js.page:143(p)
+msgid ""
+"<code>Gtk.init</code> initializes the Gtk library; this statement is "
+"mandatory for all Gtk programs."
+msgstr ""
+"ÎÎ <code>Gtk.init</code> ÎÏÏÎÎÎÏÎÎÎÎ ÏÎ ÎÎÎÎÎÎÎÎÎÎ Gtk ÎÏÏÎ Î ÏÏÏÏÎÏÎ ÎÎÎÎÎ "
+"ÏÏÎÏÏÎÏÏÎÎÎ ÎÎÎ ÏÎÎ ÏÎ ÏÏÎÎÏÎÎÎÎÏÎ Gtk."
+
+#: C/image-viewer.js.page:146(p)
+msgid ""
+"The next line creates the main window by creating a new <code>Gtk.Window</"
+"code> object. You can pass several properties to the window's constructor by "
+"using the syntax <code>{property: value, property: value, ...}</code>. In "
+"this case we are setting the title of the window."
+msgstr ""
+"Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÏÎ ÎÏÏÎÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÏÏÎÏÎÏÎÏ ÎÎÎ ÎÎÎ "
+"ÎÎÏÎÎÎÎÎÎÎÎ <code>Gtk.Window</code>. ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÏÎÏÎÏÎ ÎÏÎÎÏÎÏ ÎÎÎÏÏÎÏÎÏ "
+"ÏÏÎÎ ÎÎÏÎÏÎÎÏÎÏÏÎ ÏÎÏÎÎÏÏÎÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÏÏÎÏÎÎÎ <code>{property: "
+"value, property: value, ...}</code>. ÎÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÏÎÎÎÏÎÎ ÏÎÎ "
+"ÏÎÏÎÎ ÏÎÏ ÏÎÏÎÎÏÏÎÏ."
+
+#: C/image-viewer.js.page:147(p)
+msgid ""
+"The next line explicitly shows the window. In Gtk, every widget is hidden by "
+"default."
+msgstr ""
+"Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ ÏÎÏÎ ÎÎÏÎÎÎÎÎÎ ÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎ Gtk, ÎÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ "
+"ÎÏÏÎÎÏÎÎ ÎÏÏ ÏÏÎÎÏÎÎÎÎÎ."
+
+#: C/image-viewer.js.page:148(p)
+msgid ""
+"Finally, <code>Gtk.main</code> runs the main loop â in other words, it "
+"executes the program. The main loop listens for events (signals) from the "
+"user interface and then calls a signal handler which will do something "
+"useful. We'll learn more about signals shortly."
+msgstr ""
+"ÎÎÎÎÎÎ, ÏÎ <code>Gtk.main</code> ÏÏÎÏÎÎ ÏÎÎ ÎÏÏÎÎ ÎÏÏÏÎ â ÎÎ ÎÎÎÎ ÎÏÎÎÎ, "
+"ÎÎÏÎÎÎÎ ÏÎ ÏÏÏÎÏÎÎÎÎ. Î ÎÏÏÎÎÏ ÎÏÏÏÎÏ ÎÏÎÎÏÎ ÏÎ ÏÏÎÎÎÎÏÎ (ÏÎÎÎÏÎ) ÎÏÏ ÏÎ "
+"ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÎÎÎ ÎÏÎÎÏÎ ÎÎÎÎÎ ÎÎÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÎÏ ÏÎÏ ÎÎ ÎÎÎÎÎ ÎÎÏÎ "
+"ÏÏÎÏÎÎÎ. ÎÎ ÎÎÎÎÏÎÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎ ÏÎ ÏÎÎÎÏÎ ÏÏÎÏÎÎÎ."
+
+#: C/image-viewer.js.page:151(p)
+msgid ""
+"Save the code in <file>main.js</file> and run it. You will notice that the "
+"application does not quit when you close the window. This is because we "
+"haven't set up a signal handler to deal with the window's <code>destroy</"
+"code> (close) signal yet. We'll do this shortly, but for now you can just "
+"hit <keyseq><key>Ctrl</key><key>C</key></keyseq> in the terminal window to "
+"quit the program."
+msgstr ""
+"ÎÏÎÎÎÎÎÏÏÎ ÏÎÏ ÎÏÎÎÎÎ ÏÏÎ <file>main.js</file> ÎÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ. ÎÎ "
+"ÏÎÎÎÎÏÏÎÏÎ ÏÏÎ Î ÎÏÎÏÎÎÎÎ ÎÎÎ ÎÎÎÎÏÎÎÎÎÏÎÎ ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÏÏ "
+"ÏÏÎÎÎÎÎÎÎ ÎÏÎÎÎÎ ÎÎÎ ÎÎÎÎÏÎÏÏÎÏÎÎÎ ÎÎÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÎÏ ÎÎÎ ÎÏÏÎÎÎÎÎÎ ÎÎ ÏÎ "
+"ÏÎÎÎ ÏÎÏ ÏÎÏÎÎÏÏÎÏ <code>destroy</code> (ÎÎÎÎÏÎÎÎ) ÎÎÏÎÎ. ÎÎ ÏÎ ÎÎÎÎÏÎÎ "
+"ÏÏÎÏÎÎÎ, ÎÎÎÎ ÎÎÎ ÏÏÏÎ ÎÏÎÏÎÎÏÎ ÎÏÎÎ ÎÎ ÏÎÏÎÏÎÏÎ "
+"<keyseq><key>Ctrl</key><key>C</key></keyseq> ÏÏÎ ÏÎÏÎÎÏÏÎ ÏÎÏÎÎÏÎÎÎÏ ÎÎÎ ÎÎ "
+"ÎÏÎÏÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ."
+
+#: C/image-viewer.js.page:156(title)
+msgid "Adding classes"
+msgstr "ÎÏÎÏÎÎÎÎ ÎÎÎÏÎÏÎ"
+
+#: C/image-viewer.js.page:157(p)
+msgid ""
+"The proper way of doing Gtk programming is by using classes. Let's rewrite "
+"the simple code you just wrote using classes:"
+msgstr ""
+"Î ÎÎÏÎÎÎÎÎÎÏ ÏÏÏÏÎÏ ÎÎÎ ÎÎ ÎÎÎÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÏÏ Gtk ÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ "
+"ÎÎÎÏÎÎÏ. ÎÏ ÎÎÎÎÎÏÎÏÎÏÎÎ ÏÎÎ ÎÏÎÏ ÎÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÏÎÏÎÏÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ "
+"ÎÎÎÏÎÎÏ:"
+
+#. FIXME: Throws an error, "JS ERROR: !!!   Unhandled type int32 releasing GArgument" on Ubuntu 10.10
+#: C/image-viewer.js.page:176(p)
+msgid ""
+"Notice that the program is the same; we just moved the window creation code "
+"to our own <code>ImageViewer</code> class. The class's constructor calls the "
+"<code>_init</code> method, which creates and shows the window. We then "
+"create an instance of the class before running the main loop (<code>Gtk."
+"main</code>)."
+msgstr ""
+"ÏÎÎÎÎÏÏÏÎ ÏÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎÎÎÎ ÏÎ ÎÎÎÎÂ ÎÏÎÎÏ ÎÎÏÎÎÎÎÎÏÎÎÎ ÏÎÎ ÎÏÎÎÎÎ "
+"ÎÎÎÎÎÏÏÎÎÎÏ ÏÎÏÎÎÏÏÎÏ ÏÏÎ ÎÎÎÎ ÎÎÏ ÎÎÎÏÎ <code>ImageViewer</code>. Î "
+"ÎÎÏÎÏÎÎÏÎÏÏÎÏ ÎÎÎÏÎÏ ÎÎÎÎÎ ÏÎ ÎÎÎÎÎÎ <code>_init</code>, ÏÎÏ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ "
+"ÎÎÏÎÎÎÎÎÎ ÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎÎÏÎ ÎÎÎÎÎÏÏÎÎÏÎÎ ÎÎÎ ÏÏÎÎÎÎÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÏ ÏÏÎÎ "
+"ÏÎ ÏÏÎÎÎÎÎ ÏÎÏ ÎÏÏÎÎÏ ÎÏÏÏÎÏ (<code>Gtk.main</code>)."
+
+#: C/image-viewer.js.page:177(p)
+msgid ""
+"This code is modular and can be split into multiple files easily. This makes "
+"it cleaner and easier to read."
+msgstr ""
+"ÎÏÏÏÏ Î ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÎÏÎÏÏÏÏÏ ÎÎÎ ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎ ÏÎ ÏÎÎÎÎÏÎÎ ÎÏÏÎÎÎ "
+"ÎÏÎÎÎÎ. ÎÏÏÏ ÏÎÎ ÎÎÎÎÎ ÎÎÎÎÏÏÏÎÏÎ ÎÎÎ ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÎÎÏÏÎÎÎ."
+
+#: C/image-viewer.js.page:190(p)
+msgid "The syntax for connecting any signal to a function is:"
+msgstr "Î ÏÏÎÏÎÎÎ ÎÎÎ ÏÏÎÎÎÏÎ ÎÏÎÎÎÏÎÎÏÎÏÎ ÏÎÎÎÏÎÏ ÏÎ ÎÎÎ ÏÏÎÎÏÏÎÏÎ ÎÎÎÎÎ:"
+
+#: C/image-viewer.js.page:193(p)
+msgid ""
+"You can find signal definitions for any object in the <link href=\"http://";
+"library.gnome.org/devel/gtk/stable/ch01.html\">GTK class reference</link>."
+msgstr ""
+"ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÏÎ ÎÏÎÏÎÎÏÏ ÏÎÎÎÏÎÏ ÎÎÎ ÎÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ ÏÏÎ <link "
+"href=\"http://library.gnome.org/devel/gtk/stable/ch01.html\";>ÎÎÎÏÎÏÎ ÎÎÎÏÎÏ "
+"GTK</link>."
+
+#: C/image-viewer.js.page:196(p)
+msgid ""
+"You can simplify the code by making use of an inline function definition:"
+msgstr ""
+"ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÏÎÎÎÏÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÎÎÎÎ ÎÎÏÏÎÎÏÏÎÎÎÎ ÎÏÎÏÎÏ "
+"ÏÏÎÎÏÏÎÏÎÏ:"
+
+#: C/image-viewer.js.page:204(title)
+msgid "Closing the window"
+msgstr "ÎÎÎÎÏÎÎÎ ÏÎÏ ÏÎÏÎÎÏÏÎÏ"
+
+#: C/image-viewer.js.page:205(p)
+msgid ""
+"When you close a Gtk window it's not really closed, it's hidden. This allows "
+"you to keep the window around (which is useful if you want to ask the user "
+"if they really want to close the window, for example)."
+msgstr ""
+"ÎÏÎÎ ÎÎÎÎÎÎÏÎÎ ÎÎÎ ÏÎÏÎÎÏÏÎ Gtk ÎÎÎ ÎÎÎÎÎÎÎ ÏÏÎÎÎÎÏÎÎÎ, ÎÏÏÎÎÏÎÎ. ÎÏÏÏ "
+"ÎÏÎÏÏÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎÏÎ ÏÎÏ ÏÎÏÎÎÏÏÎÏ ÏÏÎÎÏÏÏ (ÏÎÏ ÎÎÎÎÎ ÏÏÎÏÎÎÎ ÎÎÎ ÎÎÎÎÏÎ "
+"ÎÎ ÎÎÏÎÏÎÏÎ ÎÏÏ ÏÎÎ ÏÏÎÏÏÎ ÎÎÎ ÎÎÎÎÎ ÏÏÎÎÎÎÏÎÎÎ ÎÎ ÎÎÎÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ, ÎÎÎ "
+"ÏÎÏÎÎÎÎÎÎÎ)."
+
+#: C/image-viewer.js.page:206(p)
+msgid ""
+"In our case, we really do just want to close the window. The simplest way of "
+"doing this is by connecting the <code>hide</code> signal of the GtkWindow "
+"object to a function that closes the application. Go back to the <file>image-"
+"viewer.js</file> file and add the following code to the <code>_init</code> "
+"method, on the line above <code>this.window.show</code>:"
+msgstr ""
+"ÎÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÏ, ÎÎÎÎÏÎÎ ÏÏÎÎÎÎÏÎÎÎ ÎÎ ÎÎÎÎÏÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ. Î "
+"ÎÏÎÎÏÏÏÎÏÎÏ ÏÏÏÏÎÏ ÎÎÎÎÎ ÏÏÎÎÎÎÎÏÎÏ ÏÎ ÏÎÎÎ <code>hide</code> ÏÎÏ "
+"ÎÎÏÎÎÎÎÎÎÎÎÏ GtkWindow ÎÎ ÎÎÎ ÏÏÎÎÏÏÎÏÎ ÏÎÏ ÎÎÎÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ. ÎÏÎÏÏÏÎÏÏÎ "
+"ÏÏÎ ÎÏÏÎÎÎ <file>image-viewer.js</file> ÎÎÎ ÏÏÎÏÎÎÏÏÎ ÏÎÎ ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎ "
+"ÏÏÎ ÎÎÎÎÎÎ <code>_init</code>, ÏÏÎÎ ÏÎÏÎÏÎÎÏ ÎÏÎÎÎÎ "
+"<code>this.window.show</code>:"
+
+#: C/image-viewer.js.page:207(code)
+#, no-wrap
+msgid "this.window.connect (\"hide\", Gtk.main_quit);"
+msgstr "this.window.connect (\"hide\", Gtk.main_quit)Â"
+
+#: C/image-viewer.js.page:208(p)
+msgid ""
+"This connects the <code>hide</code> signal of the window to Gtk's "
+"<code>main_quit</code> function, which ends the execution of the Gtk main "
+"loop. Once the main loop finishes, the function <code>Gtk.main</code> "
+"returns. Our program would continue to run any code written after the "
+"<code>Gtk.main ();</code> line, but since we don't have any code after that "
+"point, the program just ends."
+msgstr ""
+"ÎÏÏÏ ÏÏÎÎÎÎÎ ÏÎ ÏÎÎÎ <code>hide</code> ÏÎÏ ÏÎÏÎÎÏÏÎÏ ÏÏÎ ÏÏÎÎÏÏÎÏÎ ÏÎÏ Gtk "
+"<code>main_quit</code>, ÏÎÏ ÏÎÎÎÎÏÎÎÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÏÎÎÏ ÎÏÏÏÎÏ Gtk. "
+"ÎÏÎÎÏ Î ÎÏÏÎÎÏ ÎÏÏÏÎÏ ÏÎÎÎÎÏÏÎÎ, Î ÏÏÎÎÏÏÎÏÎ <code>Gtk.main</code> "
+"ÎÏÎÏÏÏÎÏÎÎ. ÎÎ ÏÏÏÎÏÎÎÎÎ ÎÎÏ ÏÏÎÎÏÎÎÎÎ ÎÎ ÏÏÎÏÎÎ ÎÏÎÎÎÎÎÏÎÏÎ ÎÏÎÎÎÎ ÎÏÎÎÎÎÎÎ "
+"ÎÎÏÎ ÏÎ ÎÏÎÎÎÎ <code>Gtk.main ();</code>, ÎÎÎÎ ÎÏÎÏ ÎÎÎ ÎÏÎÏÎÎ ÎÏÎÎÎÎÎÏÎÏÎ "
+"ÎÏÎÎÎÎ ÎÎÏÎ ÎÏÏ ÎÏÏÏ ÏÎ ÏÎÎÎÎÎ, ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÏÎÎ ÏÎÎÎÎÏÎÎÎ."
+
+#: C/image-viewer.js.page:218(p)
+#| 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:"
+msgid ""
+"Let's add the box and widgets to the window. Insert the following code into "
+"the <code>_init</code> method, immediately above the <code>this.window.show</"
+"code> line:"
+msgstr ""
+"ÎÏ ÏÏÎÏÎÎÏÎÏÎÎ ÎÎÎ ÏÎÎÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎÏÎÎÏÏÎ ÏÎÎ "
+"ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎ ÏÏÎ ÎÎÎÎÎÎ <code>_init</code>, ÎÎÎÏÏÏ ÏÎÎÏ ÎÏÏ ÏÎ ÎÏÎÎÎÎ "
+"<code>this.window.show</code> line:"
+
+#: C/image-viewer.js.page:222(p)
+#| 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."
+msgid ""
+"The first line creates a <code>Gtk.Box</code> called <code>main_box</code> "
+"and sets two of its properties: the <code>orientation</code> is set to "
+"vertical (so widgets are arranged in a column), and the <code>spacing</code> "
+"between the widgets is set to 0 pixels. The next line then adds the newly-"
+"created <code>Gtk.Box</code> to the window."
+msgstr ""
+"Î ÏÏÏÏÎ ÎÏÎÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ <code>Gtk.Box</code> ÏÎÏ ÎÎÎÎÎÎÎÏÎÎ "
+"<code>main_box</code> ÎÎÎ ÎÏÎÎÎÎ ÎÏÎ ÎÏÏ ÏÎÏ ÎÎÎÏÏÎÏÎÏ ÏÎÏ: ÏÎÎ "
+"<code>orientation</code> ÏÎÏ ÏÏÎÎÎÎÎÏÎÎ ÏÏÎ ÎÎÎÎÏÎ (ÎÏÏÏÎ ÏÎ ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ ÏÎÎÏÎÏÎÎÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎ), ÎÎÎ ÏÎ <code>spacing</code> ÎÎÎÎÎÏÎ ÏÏÎ "
+"ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÎÏ ÎÏÎÎ ÏÏÎÎÎÏÏÎÎ ÏÏÎ 0 ÎÎÎÎÎÎÏÏÎÎÏÎÎÎ. Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ "
+"ÎÏÎÎÏÎ ÏÏÎÏÎÎÏÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÏÎ ÎÎÎÎÎÎÎÎÏÏÎÎÎÎÎÎ <code>Gtk.Box</code>."
+
+#: C/image-viewer.js.page:228(p)
+#| msgid ""
+#| "To add some widgets to the <code>Gtk.Box</code>, insert the following "
+#| "code directly below the <code>window.add (box)</code> line:"
+msgid ""
+"To add some widgets to the <code>Gtk.Box</code>, insert the following code "
+"directly below the <code>this.window.add (main_box)</code> line:"
+msgstr ""
+"ÎÎÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÏÎ <code>Gtk.Box</code>, "
+"ÎÎÏÎÎÎÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÎÎÎ ÎÎÏÎÎÏÏ ÎÎÏÏ ÎÏÏ ÏÎÎ ÎÏÎÎÎÎ "
+"<code>this.window.add (main_box)</code>:"
+
+#: C/image-viewer.js.page:232(p)
+#| 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."
+msgid ""
+"The first line creates a new <code>Gtk.Image</code> called <code>image</"
+"code>, which will be used to display an image file. Then, the image widget "
+"is added (<em>packed</em>) into the <code>main_box</code> container using "
+"<code>Gtk.Box</code>'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>, ÏÎ ÎÏÎÎÎ ÎÎ ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ. "
+"ÎÏÎÎÏÎ, ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÎÎÏÎÎÏ ÏÏÎÏÏÎÎÎÏÎÎ (<em>ÏÎÎÎÏÎÏÎÏÎÎÎÎ</em>) "
+"ÏÏÎÎ ÏÎÏÎÎÎÏÎ <code>main_box</code> ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÎÎÎÎÎÎ ÏÎÏ "
+"<code>Gtk.Box</code> <link "
+"href=\"http://library.gnome.org/devel/gtk/stable/GtkBox.html#gtk-box-pack-";
+"start\"><code>pack_start</code></link>."
+
+#: C/image-viewer.js.page:233(p)
+#| 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>)."
+msgid ""
+"<code>pack_start</code> takes 4 arguments: the widget that is to be added to "
+"the <code>Gtk.Box</code> (<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 ÎÏÎÏÎÎÏÎ: ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ "
+"ÏÏÎÏÏÎÎÎÏÎÎ ÏÏÎ <code>Gtk.Box</code> (<code>child</code>)Â ÎÎ ÏÎ "
+"<code>Gtk.Box</code> ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎ ÏÏÎÎ ÏÏÎÏÏÎÎÎÎ ÎÎÎ ÎÏÎÏÎÎÏ "
+"ÏÏÏÏÎÏÎÎÏ (<code>expand</code>)Â ÎÎ ÏÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÎ ÎÏÏÎÏÎ ÎÎ "
+"ÎÎÎÏÏÎÎ ÏÎÎ ÏÎÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ ÎÎ ÎÎÎÎÎÏÏÎÎ ÏÎ <code>Gtk.Box</code> "
+"(<code>fill</code>)Â ÎÎÎ ÏÏÏÎÏ ÏÏÏÎÏ ÏÏÎÏÎÎ ÎÎ ÏÏÎÏÏÎÎ, ÏÎ ÎÎÎÎÎÎÏÏÎÎÏÎÎÎ, "
+"ÎÎÎÎÎÏÎ ÏÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÎÎ ÏÏÎÏÏ ÎÎÎÏÎÎÎÏ ÏÎÏ ÎÎÏÎ ÏÏÎ "
+"<code>Gtk.Box</code>, (<code>padding</code>)."
+
+#: C/image-viewer.js.page:240(p)
+#| 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."
+msgid ""
+"These lines are similar to the first two, but this time they create a "
+"<code>Gtk.Button</code> and add it to <code>main_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>main_box</code>. ÎÎÎÎÎÏÏÏÎ ÏÏÎ ÎÏÎÎÎÏÎÎ ÏÎ ÏÏÎÏÎÎ <code>expand</code> "
+"(ÏÎ ÎÎÏÏÎÏÎ) ÏÏÎ <code>false</code> ÎÎÏ, ÎÎÏ ÎÎÏÎ ÎÏÎÏÏÎÎ ÏÎ "
+"<code>true</code> ÎÎÎ ÏÎ <code>Gtk.Image</code>. ÎÏÏÏ ÎÎ ÏÏÎÎÎÎÎÏÎÎ ÏÏÎÎ "
+"ÎÎÎÏÎÎ ÎÎ ÎÎÎÏÏÎÎ ÏÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÏÎ ÎÎ ÏÎÏÎÎ ÎÏÎÎ ÏÏÎ "
+"ÏÏÎÎÎÎÎÏÎÎ. ÎÏÎÎ ÎÎÎÎÏÏÎÏÎÎÎÏÎÏÎ ÏÎ ÏÎÏÎÎÏÏÎ, ÏÎ ÎÎÎÎÎÎÏ ÏÏÎ ÎÎÏÎÏÎÏÎ ÎÎ "
+"ÏÎÏÎÎÎÎÎÎÎ ÏÎ ÎÎÎÎ, ÎÎÏ ÏÎ ÎÎÎÎÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ ÎÎ ÎÏÎÎÎÎÎ, ÎÎÏÎÎÎÎÎÎÎÎÎÏÎÏ "
+"ÏÎÎ ÏÎ ÏÏÏÎÎÎÏÎ ÏÎÏÎÎÏÏÎ."
+
+#: C/image-viewer.js.page:241(p)
+msgid ""
+"Finally, we must change the <code>this.window.show ();</code> line to read:"
+msgstr ""
+"ÎÎÎÎÎÎ, ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÎÏÎÎ ÏÎ ÎÏÎÎÎÎ <code>this.window.show ();</code> ÎÎÎ "
+"ÎÎ ÎÎÎÎÎÏÎÎ:"
+
+#: C/image-viewer.js.page:242(code)
+#, no-wrap
+msgid "this.window.show_all ();"
+msgstr "this.window.show_all ()Â"
+
+#: C/image-viewer.js.page:243(p)
+msgid ""
+"This will show the child of the Gtk window, and all of its children, and its "
+"children's children, and so on. (Remember that Gtk widgets are all hidden by "
+"default.)"
+msgstr ""
+"ÎÏÏÏ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎ ÎÎÏÎÏÎ ÏÎÏ ÏÎÏÎÎÏÏÎÏ Gtk ÎÎÎ ÏÎÎ ÏÎ ÎÎÏÎÏÎÏÎ ÏÎÏ ÎÎÎ ÏÎ "
+"ÎÎÏÎÏÎÏÎ ÏÏÎ ÎÎÏÎÏÎÏÏÎ ÏÎÏ Î.Î.Î. (ÎÎ ÎÏÎÎÏÏÎ ÏÏÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ Gtk "
+"ÎÏÏÎÎÎÏÎÎ ÏÎÎ ÎÏÏ ÏÏÎÎÏÎÎÎÎÎ)"
+
+#: C/image-viewer.js.page:248(p)
+#| 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."
+msgid ""
+"When the user clicks on the <gui>Open</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>ÎÎÎÎÎÎÎ</gui>, ÎÎÎÏ ÎÎÎÎÎÎÎÏ ÎÎ "
+"ÎÎÏÎÎÎÏÏÎÎ ÎÏÏÎ ÏÏÏÎ Î ÏÏÎÏÏÎÏ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ. ÎÏÎÎÏ ÎÎÎÎÎÎÎÎ, Î "
+"ÎÎÎÏÎÎ ÎÎ ÏÎÏÏÏÎÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ."
+
+#: C/image-viewer.js.page:249(p)
+#| 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:"
+msgid ""
+"The first step is to connect the <code>clicked</code> signal of the button "
+"to a signal handler function, which we call <code>_openClicked</code>. Put "
+"this code immediately after the <code>var open_button = new Gtk.Button</"
+"code> line where the button was created:"
+msgstr ""
+"ÎÎ ÏÏÏÏÎ ÎÎÎÎ ÎÎÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÎÏ ÎÎÏÎÏÎÎÏ "
+"ÎÎ ÎÎÎ ÏÏÎÎÏÏÎÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ, ÏÎÎ ÎÏÎÎÎ ÎÎÎÎÏÎÎ ÎÎ "
+"<code>_openClicked</code>. ÎÎÎÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÏÏ ÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ "
+"<code>var open_button = new Gtk.Button</code> ÏÏÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎÎÎÎÏÏÎÎÎÎÎÎ:"
+
+#: C/image-viewer.js.page:252(p)
+msgid ""
+"We are using the <em>Lang</em> JavaScript helper here. It allows us to "
+"connect a <em>class method</em> to the signal, rather than a plain function "
+"(without a class) which we had used before for the window's <code>hide</"
+"code> signal. Don't worry about this for now, it's just a technical detail. "
+"For it to work, you also need to put the following line at the top of the "
+"file:"
+msgstr ""
+"ÎÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÏ <em>Lang</em> JavaScript ÎÎÏ. ÎÏÎÏÏÎÏÎÎ ÏÎ ÏÏÎÎÎÏÎ "
+"ÎÎÎÏ <em>ÎÎÎÏÎÎÏ ÎÎÎÏÎÏ</em> ÎÎ ÏÎ ÏÎÎÎ, ÎÎÏÎ ÎÎÎ ÎÏÎÎ ÏÏÎÎÏÏÎÏÎ (ÏÏÏÎÏ "
+"ÎÎÎÏÎ) ÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎÎ ÏÏÎÎ ÎÎÎ ÏÎ ÏÎÎÎ ÏÎÏ ÏÎÏÎÎÏÏÎÏ <code>hide</code>. "
+"ÎÎÎ ÎÎÎÏÏÏÎÎÏÎ ÎÎÎ ÎÏÏÏ ÎÎÎ ÏÏÏÎ, ÎÎÎÎÎ ÎÏÎÎ ÎÎÎ ÏÎÏÎÎÎÎ ÎÎÏÏÎÎÎÏÎÎÎ. ÎÎÎ "
+"ÎÎ ÎÎÏÎÎÏÎÎ ÏÏÎÎÎÎÏÏÎÏÏÎ ÎÏÎÏÎÏ ÎÎ ÎÎÎÎÏÎ ÏÎÎ ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎ ÏÏÎÎ ÎÎÏÏÏÎ "
+"ÏÎÏ ÎÏÏÎÎÎÏ:"
+
+#: C/image-viewer.js.page:253(code)
+#, no-wrap
+msgid "const Lang = imports.lang;"
+msgstr "const Lang = imports.langÂ"
+
+#: C/image-viewer.js.page:258(p)
+#| 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:"
+msgid ""
+"Now we can create the <code>_openClicked()</code> method. Insert the "
+"following into the <code>ImageViewer.prototype</code> code block, after the "
+"<code>_init</code> method (and not forgetting the comma):"
+msgstr ""
+"ÎÏÏÎ ÎÏÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎÎ ÏÎ ÎÎÎÎÎÎ <code>_openClicked()</code>. "
+"ÎÎÏÎÎÎÏÎ ÏÎ ÎÎÏÎÎÏÎÎ ÏÏÎÎ ÎÎÎÎÎ ÎÏÎÎÎÎ <code>ImageViewer.prototype</code>, "
+"ÎÎÏÎ ÏÎ ÎÎÎÎÎÎ <code>_init</code> (ÎÎÎ ÎÎ ÎÎÏÎÏÎÏÎ ÏÎ ÎÏÎÎÎ):"
+
+#: C/image-viewer.js.page:281(p)
+#| 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."
+msgid ""
+"The line beginning with <code>var chooser</code> creates an <gui>Open</gui> "
+"dialog, which the user can use to choose files. We set four 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; <code>transient_for</code>, which sets the parent window of the "
+"dialog; and <code>modal</code> which, if set to <code>true</code>, prevents "
+"the user from clicking on another area of the application until the dialog "
+"is closed."
+msgstr ""
+"Î ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ <code>var chooser</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎÎ ÎÎÎÎÎÎÎ "
+"<gui>ÎÎÎÎÎÎÎÏÎÏ</gui>, ÏÎÎ ÎÏÎÎÎ Î ÏÏÎÏÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÎÎÎ "
+"ÎÏÎÎÎÎÎ ÎÏÏÎÎÏÎ. ÎÏÎÎÎÏÎÎ ÏÎÏÏÎÏÎÏ ÎÎÎÏÏÎÏÎÏ: ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎÎÏÎÎÏÂ ÏÎÎ "
+"ÎÎÎÏÎÎÎÎ (ÏÏÏÎ) ÏÎÏ ÎÎÎÎÏÎÎÏ (ÎÎÎÎÎ ÎÎÎÎÎÎÎÏ \"open\", ÎÎÎÎ ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ <code>SAVE</code> ÎÎ Î ÏÏÏÎÎÏÎ ÎÏÎÎ ÎÎ ÎÏÎÎÎÎÎÏÏÎÏÎÎ ÎÎÎ "
+"ÎÏÏÎÎÎÂ <code>transient_for</code>, ÏÎÏ ÎÏÎÎÎÎ ÏÎ ÎÎÎÏÎ ÏÎÏÎÎÏÏÎ ÏÎÏ "
+"ÎÎÎÎÏÎÎÏÂ ÎÎÎ <code>modal</code> ÏÎÏ, ÎÎÎ ÎÏÎÏÏÎÎ <code>true</code>, "
+"ÎÏÎÏÏÎÏÎÎ ÏÎ ÏÏÎÏÏÎ ÎÏÏ ÎÎÎÎ ÏÎ ÎÎÎ ÎÎÎÎ ÏÎÏÎÎÏÎ ÏÎÏ ÎÏÎÏÎÎÎÎÏ ÎÎÏÏÎ ÏÎ "
+"ÎÎÎÎÏÎÎÎ ÏÎÏ ÎÎÎÎÏÎÎÏ."
+
+#: C/image-viewer.js.page:294(p)
+#| 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."
+msgid ""
+"<code>chooser.run</code> displays the <gui>Open</gui> dialog. The dialog "
+"will wait for the user to choose an image; when they do, <code>chooser.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>ÎÎÎÎÎÎÎ</gui>. Î "
+"ÎÎÎÎÎÎÎÏ ÎÎ ÏÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎÂ ÏÏÎÎ ÎÎÎÎÎÎÎÎ, ÏÎ "
+"<code>chooser.run</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÎÎ ÏÎÎÎ <output>1</output> (ÎÎ "
+"ÎÏÎÏÏÏÎÏÎÎ <output>0</output> ÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎÎ <gui>ÎÎÏÏÏÏÎ</gui>). Î "
+"ÏÏÏÏÎÏÎ <code>if</code> ÏÎ ÎÎÎÎÏÎÎ."
+
+#: C/image-viewer.js.page:307(p)
+#| 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!"
+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 JavaScript and Gtk) in not much time at all!"
+msgstr ""
+"ÎÎÎÏ Î ÎÏÎÎÎÎÏ ÏÎÏ ÏÏÎÎÎÎÎÏÏÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÏÏÏÎ ÏÏÎ ÎÎÏÎ ÏÎÏ, ÎÏÏÏÎ "
+"ÎÎÎÎÎÎÏÏÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎ. ÎÏÏÏ ÎÏÎÎÎÂ ÎÎÎÏ ÏÎÎÏÏÏ ÎÎÎÏÎÏÏÎÎÎÏÏ "
+"ÏÏÎÎÎÎÎÎÏ ÎÎÎÏÎÏÎ (ÎÎÎ ÎÎÎ ÏÎÏÎÎÎÎÏÎ ÏÎÏ JavaScript ÎÎÎ Gtk) ÏÎ ÎÎÎÏÎÏÏÎ "
+"ÏÏÏÎÎ!"
+
+#: C/image-viewer.js.page:312(p)
+#| msgid ""
+#| "If you run into problems with the tutorial, compare your code with this "
+#| "<link href=\"image-viewer/image-viewer.py\">reference code</link>."
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"image-viewer/image-viewer.js\">reference code</link>."
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ "
+"ÏÎÎ <link href=\"image-viewer/image-viewer.js\">ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+
+#: C/image-viewer.cpp.page:8(desc)
+#| msgid ""
+#| "A little bit more than a simple \"Hello world\" application - write an "
+#| "image viewer in GTK."
+msgid "A little bit more than a simple \"Hello world\" GTKmm application."
+msgstr "ÎÎÎ ÎÎÎÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÏÏ ÎÏÎÎ ÎÏÎÏÎÎÎÎ GTKmm ÏÎÎ ÏÎ \"Hello, world!\"."
+
+#: C/image-viewer.cpp.page:21(title) C/image-viewer.c.page:22(title)
+msgid "Image Viewer"
+msgstr "ÎÏÎÎÎÎÎ ÎÎÎÏÎÏÎ"
+
+#: C/image-viewer.cpp.page:26(p)
+msgid "Some basic concepts of C++/GObject programming"
+msgstr "ÎÎÏÎÎÎÏ ÎÎÏÎÎÎÏ ÎÎÎÎÎÎÏ ÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ C++/GObject"
+
+#: C/image-viewer.cpp.page:27(p)
+#| msgid "A first Gtk application"
+msgid "How to write a Gtk application in C++"
+msgstr "ÎÏÏ ÎÎ ÎÏÎÏÎÏÎ ÎÎÎ ÎÏÎÏÎÎÎÎ Gtk ÏÎ C++"
+
+#: C/image-viewer.cpp.page:41(p)
+#| 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."
+msgid ""
+"Choose <gui>GTKmm (Simple)</gui> from the <gui>C++</gui> tab, click "
+"<gui>Forward</gui>, and fill out your details on the next few pages. Use "
+"<file>image-viewer</file> as project name and directory."
+msgstr ""
+"ÎÏÎÎÎÎÏÎ <gui>GTKmm (ÎÏÎÏ)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>C++</gui>, ÏÎÏÎÏÏÎ "
+"<gui>ÎÏÏÎÏÏÎ</gui> ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ ÎÎÎÎÏ "
+"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ <file>image-viewer</file> ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ "
+"ÏÎÏ ÎÎÏÎÎÏÎÎÏ."
+
+#: C/image-viewer.cpp.page:44(p)
+#| 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>."
+msgid ""
+"Make sure that <gui>Use GtkBuilder for user interface</gui> is disabled as "
+"we will create the UI manually in this tutorial. Check the <link xref="
+"\"guitar-tuner.cpp\">Guitar-Tuner</link> tutorial if you want to learn how "
+"to use the interface builder."
+msgstr ""
+"ÎÎÎÎÏÏÎÏÏÎÎÏÎ ÏÏÎ ÎÏÎÎÎÏÎÎÏÎÎÎÏÎÏÎ ÏÎ <gui>ÎÏÎÏÎ ÏÎÏ GtkBuilder ÎÎÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎÏÎ</gui> ÎÏÎÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÏÎÎÏÎÎÎÎÎÏÎ ÏÎ ÎÏÏÏ ÏÎ "
+"ÎÎÎÎÎÎ. ÎÎÎÎÎÏÏÏÎ ÏÎ ÎÎÎÎÎÎ <link xref=\"guitar-tuner.cpp\">ÏÏÎÎÎÏÏÎÏ "
+"ÎÎÎÎÏÎÏ</link> ÎÎÎ ÎÎÎÎÏÎ ÎÎ ÎÎÎÎÏÎ ÏÎ ÏÏÎÏÎ ÏÎÏ ÎÎÏÎÏÎÎÏÎÏÏÎ ÎÎÎÏÎÏÎÏ."
+
+#: C/image-viewer.cpp.page:49(p)
+#| 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:"
+msgid ""
+"Click <gui>Apply</gui> and the project will be created for you. Open "
+"<file>src/main.cc</file> from the <gui>Project</gui> or <gui>File</gui> "
+"tabs. You should see some code which starts with the lines:"
+msgstr ""
+"ÎÎÏÎÏÏÎ <gui>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÏÎÏ. ÎÎÎÎÎÏÎ "
+"<file>src/main.cc</file> ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ <gui>ÎÏÎÎ</gui> Î "
+"<gui>ÎÏÏÎÎÎ</gui>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÎÏÎÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎ ÎÎ ÏÎÏ "
+"ÎÏÎÎÎÎÏ:"
+
+#: C/image-viewer.cpp.page:61(p) C/guitar-tuner.cpp.page:64(p)
+#| 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:"
+msgid ""
+"This is a very basic C++ code setting up GTKmm. More details are given "
+"below; skip this list if you understand the basics:"
+msgstr ""
+"ÎÏÏÏÏ ÎÎÎÎÎ ÎÎÎÏ ÏÎÎÏ ÎÎÏÎÎÏÏ ÎÏÎÎÎÎÏ C++ ÎÎÎÎÏÎÏÏÎÏÎÏ GTKmm. ÎÎÏÎÏÏÏÏÎÏÎÏ "
+"ÎÎÏÏÎÎÎÏÎÎÎÏ ÎÎÎÎÎÏÎÎ ÏÎÏÎÎÎÏÏÂ ÏÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎ ÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÎÎÎÏÎ "
+"ÏÎ ÎÎÏÎÎÎ:"
+
+#: C/image-viewer.cpp.page:64(p)
+msgid ""
+"The three <code>#include</code> lines at the top include the <code>config</"
+"code> (useful autoconf build defines), <code>gtkmm</code> (user interface) "
+"and <code>iostream</code> (C++-STL) libraries. Functions from these "
+"libraries are used in the rest of the code."
+msgstr ""
+"ÎÎ ÏÏÎÎÏ ÎÏÎÎÎÎÏ <code>#include</code> ÏÏÎÎ ÎÎÏÏÏÎ ÏÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎÎ "
+"<code>config</code> (ÎÏÎÎÎÎ ÏÏÎÏÎÎÎ ÎÎÏÎÏÎÎÏÎ ÏÎÏ autoconf), "
+"<code>gtkmm</code> (ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ) ÎÎÎ ÎÎÎÎÎÎÎÎÎÎÏ <code>iostream</code> "
+"(C++-STL). ÎÏÎÎÏÏÎÏÎÎÏ ÎÏÏ ÎÏÏÎÏ ÏÎÏ ÎÎÎÎÎÎÎÎÎÎÏ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÏÎÎ "
+"ÏÏÏÎÎÎÏÎ ÎÏÎÎÎÎ."
+
+#: C/image-viewer.cpp.page:67(p)
+msgid ""
+"The <code>main</code> function creates a new (empty) window and sets the "
+"window title."
+msgstr ""
+"Î ÏÏÎÎÏÏÎÏÎ <code>main</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÎ (ÎÎÎÎÎ) ÏÎÏÎÎÏÏÎ ÎÎÎ ÎÏÎÎÎÎ "
+"ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÏÎÏÎÎÏÏÎÏ."
+
+#: C/image-viewer.cpp.page:70(p)
+msgid ""
+"The <code>kit::run()</code> call starts the GTKmm main loop, which runs the "
+"user interface and starts listening for events (like clicks and key "
+"presses). As we give the window as an argument to that function, the "
+"application will automatically exit when that window is closed."
+msgstr ""
+"Î ÎÎÎÏÎ <code>kit::run()</code> ÎÏÏÎÎÎÎ ÏÎÎ ÎÏÏÎÎ ÎÏÏÏÎ GTKmm, ÏÎÏ ÎÎÏÎÎÎÎ "
+"ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÎÎÎ ÎÏÏÎÎÎÎ ÏÎÎ ÎÏÎÎÏÎÏÎ ÎÎÎ ÏÏÎÎÎÎÏÎ (ÏÏÏÏ ÎÎÎÎ ÎÎÎ "
+"ÏÎÏÎÎÎÏÎ ÏÎÎÎÏÏÎÏ). ÎÎÎÏÏ ÎÎÎÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÏÏ ÏÏÎÏÎÎ ÏÎ ÎÏÏÎÎ ÏÎ "
+"ÏÏÎÎÏÏÎÏÎ, Î ÎÏÎÏÎÎÎÎ ÎÎ ÎÎÎÎÏÎÎÎÎÏÎÎ ÎÏÏÏÎÎÏÎ ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÏÎÎ."
+
+#: C/image-viewer.cpp.page:77(p) C/image-viewer.c.page:79(p)
+#: C/guitar-tuner.cpp.page:79(p) C/guitar-tuner.c.page:84(p)
+msgid ""
+"Press <gui>Execute</gui> on the next window that appears to configure a "
+"debug build. You only need to do this once, for the first build."
+msgstr ""
+"ÎÎÏÎÏÏÎ <gui>Execute</gui> ÏÏÎ ÎÏÏÎÎÎÎ ÏÎÏÎÎÏÏÎ ÏÎÏ ÎÎÏÎÎÎÎÎÏÎÎ ÎÎÎ ÏÏÎÎÎÏÎ "
+"ÎÎÏÎÏÎÎÏÎÏ ÎÏÎÏÏÎÎÎÎÏÏÏÎÏ. ÎÏÎÎÎÎÎÏÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ ÎÏÎÎ ÎÎÎ ÏÎÏÎ, ÎÎÎ "
+"ÏÎÎ ÏÏÏÏÎ ÎÎÏÎÏÎÎÏÎ."
+
+#: C/image-viewer.cpp.page:82(p)
+msgid ""
+"Now we will bring life into the empty window. GTKmm organizes the user "
+"interface with <code>Gtk::Container</code>s that can contain other widgets "
+"and even other containers. Here we will use the simplest available "
+"container, a <code>Gtk::Box</code>:"
+msgstr ""
+"ÎÏÏÎ ÎÎÎÎÏÎÎ ÎÏÎ ÏÏÎ ÎÎÎÎÎ ÏÎÏÎÎÏÏÎ. ÎÎ GTKmm ÎÏÎÎÎÏÎÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÎÎ "
+"<code>Gtk::Container</code> ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ "
+"ÎÎÎ ÎÎÏÎÎ ÎÎÎÎÏÏ ÏÎÏÎÎÎÏÎÏ. ÎÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎÎ ÎÏÎÎÏÏÏÎÏÎ ÎÎÎÎÎÏÎÎÎ "
+"ÏÎÏÎÎÎÏÎ, ÎÎÎÎ <code>Gtk::Box</code>:"
+
+#: C/image-viewer.cpp.page:115(p)
+msgid ""
+"The first lines create the widgets we want to use: a button for opening up "
+"an image, the image view widget itself and the box we will use as a "
+"container."
+msgstr ""
+"ÎÎ ÏÏÏÏÎÏ ÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎ ÎÏÎÎÏÎÎÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÎÎ ÏÏÎÏÎ. ÎÎÎ "
+"ÎÎÏÎÏÎ ÎÎÎ ÎÎÎÎÎÎÎ ÎÎÎÏ ÎÎÎÏÎÎÏ, ÏÎ ÎÎÎÎ ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÏÎÎÎÎÎÏ ÏÎÏ "
+"ÎÎÎÏÎÎÏ ÎÎÎ ÏÎ ÏÎÎÎÏÎÎ ÏÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÏ ÏÎÏÎÎÎÏÎ."
+
+#: C/image-viewer.cpp.page:118(p)
+msgid ""
+"The calls to <code>pack_start</code> add the two widgets to the box and "
+"define their behaviour. The image will expand into any available space while "
+"the button will just be as big as needed. You will notice that we don't set "
+"explicit sizes on the widgets. In GTKmm this is usually not needed as it "
+"makes it much easier to have a layout that looks good in different window "
+"sizes. Next, the box is added to the window."
+msgstr ""
+"ÎÎ ÎÎÎÏÎÎÏ ÏÏÎ <code>pack_start</code> ÏÏÎÏÎÎÏÎÏÎ ÏÎ ÎÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ "
+"ÏÏÎ ÏÎÎÎÏÎÎ ÎÎÎ ÎÏÎÎÎÏÎ ÏÎ ÏÏÎÏÎÏÎÏÎÏÎ ÏÎÏÏ. Î ÎÎÎÏÎÎ ÎÎ ÎÏÎÎÏÎÎÎÎ ÏÎ ÎÎÎÎ "
+"ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ, ÎÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎ ÎÎÎÎÎ ÎÏÎÎ ÏÏÏÎ ÎÎÎÎÎÎ ÏÏÎ ÏÏÎÎÎÎÎÏÎÎ. ÎÎ "
+"ÏÎÏÎÏÎÏÎÏÎÏÎ ÏÏÎ ÎÎÎ ÎÏÎÎÎÏÎÎ ÏÎÏÎ ÎÎÎÎÎÎ ÏÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ. ÎÏÎ GTKmm "
+"ÎÏÏÏ ÏÏÎÎÎÏÏ ÎÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÏÎÎÎÎ ÎÎÎÎÎ ÏÎÎ ÎÏÎÏ ÎÎ ÎÏÎÏÎ ÎÎÎ ÎÎÎÏÎÎÎ ÏÎÏ "
+"ÏÎÎÎÎÏÎÎ ÎÎÎÎ ÎÎ ÎÎÎÏÎÏÎÏÎÎÎ ÎÎÎÎÎÎ ÏÎÏÎÎÏÏÏÎ. ÎÏÎ ÏÏÎÎÏÎÎÎ, ÏÎ ÏÎÎÎÏÎÎ "
+"ÏÏÎÏÏÎÎÎÏÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ."
+
+#: C/image-viewer.cpp.page:124(p)
+msgid ""
+"We need to define what happens when the user clicks on the button. GTKmm "
+"uses the concept of <em>signals</em>. When the button is clicked, it fires "
+"the <em>clicked</em> signal, which we can connect to some action. This is "
+"done using the <code>signal_clicked().connect</code> method which tells "
+"GTKmm to call the <code>on_open_image</code> function when the button is "
+"clicked. We will define the <em>callback</em> in the next section."
+msgstr ""
+"ÎÏÎÎÎÎÏÎÎÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎÎÎÎÎ ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎ ÏÎ ÎÎÎ ÏÎÎÎÏÏÎ. ÎÎ "
+"GTKmm ÏÏÎÏÎÎÎÏÎÎÎÎ ÏÎÎ ÎÎÎÎÎÎ ÏÏÎ <em>ÏÎÎÎÏÏÎ</em>. ÎÏÎÎ ÏÎ ÎÎÏÎÏÎ "
+"ÏÎÏÎÎÏÎÎ, ÎÎÎÎÎÎ ÏÎ ÏÎÎÎ <em>ÏÎÏÎÎÎÎÎ</em>, ÏÎÏ ÎÏÎÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÎÎ "
+"ÎÎÏÎÎÎ ÎÎÎÏÎÎÎÎ. ÎÏÏÏ ÎÎÎÎÏÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÎÎÎÎÎÎ "
+"<code>signal_clicked().connect</code> ÏÎÏ ÎÎÎÎ ÏÏÎ GTKmm ÎÎ ÎÎÎÎÏÎÎ ÏÎ "
+"ÏÏÎÎÏÏÎÏÎ <code>on_open_image</code> ÏÏÎÎ ÏÎ ÎÎÏÎÏÎ ÏÎÏÎÎÏÎÎ. ÎÎ ÎÏÎÏÎÏÎÎ "
+"ÏÎÎ <em>ÎÏÎÎÎÎÎÎÏÎ</em> ÏÏÎÎ ÎÏÏÎÎÎÎ ÎÎÏÏÎÏÎ."
+
+#: C/image-viewer.cpp.page:128(p)
+msgid ""
+"The last step is to show all widgets in the window using "
+"<code>show_all_children()</code>. This is equivalent to using the <code>show"
+"()</code> method on all our child widgets."
+msgstr ""
+"ÎÎ ÏÎÎÎÏÏÎÎÎ ÎÎÎÎ ÎÎÎÎÎ Î ÎÎÏÎÎÎÏÎ ÏÎÏÎ ÏÏÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ <code>show_all_children()</code>. ÎÏÏÏ ÎÎÎÎÎ ÎÏÎÎÏÎÎÎÎ ÎÏ "
+"ÏÎ ÏÏÎÏÎ ÏÎÏ ÎÎÎÏÎÎÏ <code>show()</code> ÏÎ ÏÎÎ ÏÎ ÎÎÏÎÏÎÏÎ ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ."
+
+#: C/image-viewer.cpp.page:137(p)
+msgid ""
+"We will now define the signal handler for the <em>clicked</em> signal or the "
+"button we mentioned before. Add this code before the <code>main</code> "
+"method."
+msgstr ""
+"ÎÎ ÎÏÎÏÎÏÎÎ ÏÏÏÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÎÏ ÎÎÎ ÏÎ ÏÎÎÎ <em>ÏÎÏÎÎÎÎÎ</em> Î ÎÎÎ ÏÎ "
+"ÎÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÏÎÎÎ ÏÏÎÎ. ÎÏÎÏÎÎÏÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÏÎÎ ÏÎ ÎÎÎÎÎÎ "
+"<code>main</code>."
+
+#: C/image-viewer.cpp.page:175(p)
+msgid ""
+"The dialog for choosing the file is created using the <code>Gtk::"
+"FileChooserDialog</code> constructor. This takes the title and type of the "
+"dialog. In our case, it is an <em>Open</em> dialog."
+msgstr ""
+"Î ÎÎÎÎÎÎÎÏ ÎÏÎÎÎÎÎÏ ÏÎÏ ÎÏÏÎÎÎÏ ÎÎÎÎÎÏÏÎÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ "
+"ÎÎÏÎÏÎÎÏÎÏÏÎ <code>Gtk::FileChooserDialog</code>. ÎÏÏÏ ÏÎÎÏÎÎÎ ÏÎÎ ÏÎÏÎÎ ÎÎÎ "
+"ÏÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ. ÎÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÏ, ÎÎÎÎÎ ÎÎÎÏ ÎÎÎÎÎÎÎÏ "
+"<em>ÎÎÎÎÎÎÎÏÎÏ</em>."
+
+#: C/image-viewer.cpp.page:179(p)
+msgid ""
+"The next two lines add an <em>Open</em> and a <em>Close</em> button to the "
+"dialog."
+msgstr ""
+"ÎÎ ÎÏÏÎÎÎÎÏ ÎÏÎ ÎÏÎÎÎÎÏ ÏÏÎÏÎÎÏÎÏÎ ÎÎÎ ÎÎÏÎÏÎ <em>ÎÎÎÎÎÎÎÏÎÏ</em> ÎÎÎ ÎÎÎ "
+"<em>ÎÎÎÎÏÎÎÎÏÎÏ</em> ÏÏÎ ÎÎÎÎÎÎÎ."
+
+#: C/image-viewer.cpp.page:181(p)
+msgid ""
+"The second argument to the <code>add_button()</code> method is a value to "
+"identify the clicked button. We use predefined values provided by GTKmm "
+"here, too."
+msgstr ""
+"ÎÎ ÎÎÏÏÎÏÎ ÏÏÎÏÎÎ ÏÏÎ ÎÎÎÎÎÎ <code>add_button()</code> ÎÎÎÎÎ ÎÎÎ ÎÎÎ "
+"ÎÎÎÎÏÎÏÎÎÏ ÏÎÏ ÏÎÏÎÎÎÎÎÏ ÎÎÏÎÏÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÏÎÎÎÎÎÏÎÏÎÎÎÎÏ ÏÎÎÎÏ ÏÎÏ "
+"ÏÎÏÎÏÎÎÏÎÎ ÎÏÏ ÏÎ GTKmm ÎÎÏ, ÎÏÎÏÎÏ."
+
+#: C/image-viewer.cpp.page:186(p)
+#| 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."
+msgid ""
+"The next two 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>ÎÎÎÎÎÎÎ</gui> ÎÎ "
+"ÎÎÏÎÎÎÎÎÎ ÎÏÎÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÏÎÎÏÎ ÎÏÏ ÏÎ "
+"<code>Gtk::Image</code>. ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ ÏÎÎÏÏÎÏ ÎÎÎÎÎÏÏÎÎÎÏÎÎ ÏÏÏÏÎÂ ÎÏÎÎÏÎ "
+"ÏÏÎÏÎÎÏÎÏÎÎ ÏÎÎ ÏÎ ÎÎÎÎ ÏÏÎ ÎÏÏÎÎÏÎ ÏÎÏ ÏÏÎÏÏÎÏÎÎÎÎÏÎÎ ÎÏÏ ÏÏÎ ÏÎÎÏÏÎ ÏÎÏÎ "
+"ÏÏÎ ÎÎÎÏÎ ÎÏÏÎÎÎ ÏÎÏ ÏÏÎÏÏÎÏÎÎÎÎÏÎÎ ÎÏÏ ÏÎ <code>Gdk::Pixbuf</code> (ÏÎÏ "
+"ÏÎÏÎÎÎÎÎÎÎÎÎ ÏÎÏ ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÎÏÏÎÏ ÎÎÎÏÎÏÎ ÏÏÏÏ PNG ÎÎÎ JPEG) ÏÏÎ ÏÎÎÏÏÎ. "
+"ÎÎÎÎÏ, ÎÏÎÎÎÏÎÎ ÎÏÏÏ ÏÎ ÏÎÎÏÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ "
+"<gui>ÎÎÎÎÎÎÎ</gui>."
+
+#: C/image-viewer.cpp.page:187(p)
+msgid ""
+"<code>Glib::RefPtr</code> is a smart pointer used here, that makes sure that "
+"the filter is destroyed when there is no reference to it anymore."
+msgstr ""
+"Î <code>Glib::RefPtr</code> ÎÎÎÎÎ ÎÎÎÏ ÎÎÏÏÎÎÏ ÎÎÎÎÏÎÏ ÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ "
+"ÎÎÏ, ÎÏÏÏ ÎÏÎÎÎÎÎÎÏÎÎÎ ÏÏÎ ÏÎ ÏÎÎÏÏÎ ÎÎÏÎÏÏÏÎÏÎÏÎÎ ÏÏÎÎ ÎÎÎ ÏÏÎÏÏÎÎ ÎÎÎÏÎÏÎ "
+"ÎÎÎ ÎÏÏÏ ÏÎÎ."
+
+#: C/image-viewer.cpp.page:191(p)
+#| 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."
+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 <code>Gtk::RESPONSE_ACCEPT</code> (it would return "
+"<code>Gtk::RESPONSE_CANCEL</code> if the user clicked <gui>Cancel</gui>). "
+"The <code>switch</code> statement tests for this."
+msgstr ""
+"Î <code>dialog.run</code> ÎÎÏÎÎÎÎÎÎ ÏÎ ÎÎÎÎÎÎÎ <gui>ÎÎÎÎÎÎÎ</gui>. Î "
+"ÎÎÎÎÎÎÎÏ ÎÎ ÏÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎÂ ÏÏÎÎ ÎÎÎÎÎÎÎÎ, Î "
+"<code>dialog.run</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÎÎ ÏÎÎÎ "
+"<code>Gtk::RESPONSE_ACCEPT</code> (ÎÎ ÎÏÎÏÏÏÎÏÎÎ "
+"<code>Gtk::RESPONSE_CANCEL</code> ÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎÎ <gui>ÎÎÏÏÏÏÎ</gui>). "
+"Î ÏÏÏÏÎÏÎ <code>switch</code> ÎÎÎÎÏÎÎ ÎÎÎ ÎÏÏÏ."
+
+#: C/image-viewer.cpp.page:194(p)
+msgid ""
+"We hide the <gui>Open</gui> dialog because we don't need it any more. The "
+"dialog would be hidden later anyway, as it is only a local variable and is "
+"destroyed (and therefore hidden) when the scope ends."
+msgstr ""
+"ÎÏÏÎÎÏÎÎ ÏÎ ÎÎÎÎÎÎÎ <gui>ÎÎÎÎÎÎÎ</gui> ÎÏÎÎÎÎ ÎÎÎ ÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎ ÏÎÎ. Î "
+"ÎÎÎÎÎÎÎÏ ÎÎ ÎÏÏÏÏÎÎ ÎÏÎÏÏÎÏÎ ÏÎ ÎÎÎÎ ÏÎÏÎÏÏÏÏÎ, ÎÎÎÏÏ ÎÎÎÎÎ ÎÎÎ ÏÎÏÎÎÎ "
+"ÎÎÏÎÎÎÎÏÎ ÎÏÎÎ ÎÎÎ ÎÎÏÎÏÏÏÎÏÎÏÎÎ (ÎÎÎ ÏÏÎÎÏÏÏ ÎÏÏÎÎÏÎÎ) ÏÏÎÎ Î ÎÎÎÎÎÎÎÎ "
+"ÏÎÎÎÎÏÎÎÎ."
+
+#: C/image-viewer.cpp.page:197(p)
+#| 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."
+msgid ""
+"Assuming that the user did click <gui>Open</gui>, the next line loads the "
+"file into the <code>Gtk::Image</code> so that it is displayed."
+msgstr ""
+"ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎ ÏÎ <gui>ÎÎÎÎÎÎÎ</gui>, Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ "
+"ÏÎÏÏÏÎÎÎ ÏÎ ÎÏÏÎÎÎ ÏÏÎ <code>Gtk::Image</code>, ÎÏÏÎ ÏÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÏÎÎ."
+
+#: C/image-viewer.cpp.page:206(p) C/image-viewer.c.page:217(p)
+msgid ""
+"If you haven't already done so, choose the <file>Debug/src/image-viewer</"
+"file> application in the dialog that appears. Finally, hit <gui>Run</gui> "
+"and enjoy!"
+msgstr ""
+"ÎÎÎ ÎÎÎ ÏÎ ÎÏÎÏÎ ÎÎÎ ÎÎÎÎÎ, ÎÏÎÎÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ <file>Debug/src/image-"
+"viewer</file> ÏÏÎÎ ÎÎÎÎÎÎÎ ÏÎÏ ÎÎÏÎÎÎÎÎÏÎÎ. ÎÎÎÎÎÎ, ÏÎÏÎÏÏÎ "
+"<gui>ÏÏÎÎÎÎÎ</gui> ÎÎÎ ÎÏÎÎÎÏÏÏÎ!"
+
+#: C/image-viewer.cpp.page:211(p)
+#| msgid ""
+#| "If you run into problems with the tutorial, compare your code with this "
+#| "<link href=\"image-viewer/image-viewer.py\">reference code</link>."
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"image-viewer/image-viewer.cc\">reference code</link>."
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ "
+"ÏÎÎ <link href=\"image-viewer/image-viewer.cc\">ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+
+#: C/image-viewer.c.page:27(p)
+msgid "Some basic concepts of C/GObject programming"
+msgstr "ÎÎÏÎÎÎÏ ÎÎÏÎÎÎÏ ÎÎÎÎÎÎÏ ÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ C/GObject"
+
+#: C/image-viewer.c.page:28(p)
+#| msgid "A first Gtk application"
+msgid "How to write a Gtk application in C"
+msgstr "ÎÏÏ ÎÎ ÎÏÎÏÎÏÎ ÎÎÎ ÎÏÎÏÎÎÎÎ Gtk ÏÎ C"
+
+#: C/image-viewer.c.page:42(p)
+#| 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."
+msgid ""
+"Choose <gui>Gtk+ (Simple)</gui> from the <gui>C</gui> tab, click "
+"<gui>Continue</gui>, and fill out your details on the next few pages. Use "
+"<file>image-viewer</file> as project name and directory."
+msgstr ""
+"ÎÏÎÎÎÎÏÎ <gui>Gtk+ (ÎÏÎÏ)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>C</gui>, ÏÎÏÎÏÏÎ "
+"<gui>ÏÏÎÎÏÎÎÎ</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
+"ÎÎÎÎÏ ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ <file>image-viewer</file> ÏÏ ÏÎÎÎÎ ÏÎÏ "
+"ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÎÎÏÎÎÏÎÎÏ."
+
+#: C/image-viewer.c.page:45(p)
+#| 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>."
+msgid ""
+"Make sure that <gui>Use GtkBuilder for user interface</gui> is disabled as "
+"we will create the UI manually in this tutorial. Check the <link xref="
+"\"guitar-tuner.c\">Guitar-Tuner</link> tutorial if you want to learn how to "
+"use the interface builder."
+msgstr ""
+"ÎÎÎÎÎÏÎÎÎÏÎ ÏÏÎ ÎÏÎÎÎÏÎÎÏÎÎÎÏÎÏÎ ÏÎ <gui>ÏÏÎÏÎ ÏÎÏ GtkBuilder ÎÎÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎÏÎ</gui> ÎÏÎÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÏÎÎÏÎÎÎÎÎÏÎ ÏÎ ÎÏÏÏ ÏÎ "
+"ÎÎÎÎÎÎ. ÎÎÎÎÎÏÏÏÎ ÏÎ ÎÎÎÎÎÎ <link xref=\"guitar-tuner.c\">ÏÏÎÎÎÏÏÎÏ "
+"ÎÎÎÎÏÎÏ</link> ÎÎÎ ÎÎÎÎÏÎ ÎÎ ÎÎÎÎÏÎ ÏÎ ÏÏÎÏÎ ÏÎÏ ÎÎÏÎÏÎÎÏÎÏÏÎ ÎÎÎÏÎÏÎÏ."
+
+#: C/image-viewer.c.page:60(p)
+#| 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:"
+msgid ""
+"C is a rather verbose language, so don't be surprised that the file contains "
+"quite a lot of code. Most of it is template code. It loads an (empty) window "
+"and shows it. More details are given below; skip this list if you understand "
+"the basics:"
+msgstr ""
+"Î C ÎÎÎÎÎ ÎÎÎ ÎÎÎÎÎÎ ÏÎÏÎÎÏÎÏÎÎÎ ÎÎÏÏÏÎ, ÎÏÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÏÎ ÏÎÏ ÏÎ ÎÏÏÎÎÎ "
+"ÏÎÏÎÎÏÎÎ ÏÎÎÏ ÎÏÎÎÎÎ. Î ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÏÏÏÏÏÏÎ ÎÏÎÎÎÎ. ÎÎÏÏÏÎÎÎ "
+"ÎÎÎ (ÎÎÎÏ) ÏÎÏÎÎÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÎÎÎÎÎ. ÎÎÏÎÏÏÏÏÎÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÏÎÏÏÎÏÎ ÏÎÎ "
+"ÎÎÏÏÂ ÏÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎ ÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎ ÎÎÏÎÎÎ:"
+
+#: C/image-viewer.c.page:64(p) C/guitar-tuner.c.page:69(p)
+msgid ""
+"The three <code>#include</code> lines at the top include the <code>config</"
+"code> (useful autoconf build defines), <code>gtk</code> (user interface) and "
+"<code>gi18n</code> (internationalization) libraries. Functions from these "
+"libraries are used in the rest of the code."
+msgstr ""
+"ÎÎ ÏÏÎÎÏ ÎÏÎÎÎÎÏ <code>#include</code> ÏÏÎÎ ÎÎÏÏÏÎ ÏÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎÎ "
+"<code>config</code> (ÎÏÎÎÎÎ ÏÏÎÏÎÎÎ ÎÎÏÎÏÎÎÏÎ ÏÎÏ autoconf), "
+"<code>gtk</code> (ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ) ÎÎÎ ÎÎÎÎÎÎÎÎÎÎÏ <code>gi18n</code> "
+"(ÎÎÎÎÎÎÏÎÎÎÏÎ). ÎÏÎÎÏÏÎÏÎÎÏ ÎÏÏ ÎÏÏÎÏ ÏÎÏ ÎÎÎÎÎÎÎÎÎÎÏ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÏÎÎ "
+"ÏÏÏÎÎÎÏÎ ÎÏÎÎÎÎ."
+
+#: C/image-viewer.c.page:67(p)
+msgid ""
+"The <code>create_window</code> function creates a new (empty) window and "
+"connects a signal to exit the application when that window is closed."
+msgstr ""
+"Î ÏÏÎÎÏÏÎÏÎ <code>create_window</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÎ (ÎÎÎÎÎ) ÏÎÏÎÎÏÏÎ "
+"ÎÎÎ ÏÏÎÎÎÎÎ ÎÎÎ ÏÎÎÎ ÎÎÎ ÎÎÎÎÎ ÏÎÏ ÎÏÎÏÎÎÎÎÏ ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÎÎ."
+
+#: C/image-viewer.c.page:71(p) C/guitar-tuner.c.page:76(p)
+#| 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."
+msgid ""
+"The <code>main</code> function is run by default when you start a C "
+"application. It calls a few functions which set up and then run the "
+"application. The <code>gtk_main</code> function starts the GTK main loop, "
+"which runs the user interface and starts listening for events (like clicks "
+"and key presses)."
+msgstr ""
+"Î ÏÏÎÎÏÏÎÏÎ <code>main</code> ÏÏÎÏÎÎ ÎÏÏ ÏÏÎÎÏÎÎÎÎÎ ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÎÎÎ "
+"ÎÏÎÏÎÎÎÎ C. ÎÎÎÎÎ ÎÎÎÎÏ ÏÏÎÎÏÏÎÏÎÎÏ ÏÎÏ ÏÏÎÎÎÎÎÏÎ ÎÎÎ ÎÏÎÎÏÎ ÎÎÏÎÎÎÏÎ ÏÎÎ "
+"ÎÏÎÏÎÎÎÎ. Î ÏÏÎÎÏÏÎÏÎ <code>gtk_main</code> ÎÎÎÎÎÎ ÏÎÎ ÎÏÏÎÎ ÎÏÏÏÎ ÏÎÏ GTK, "
+"ÏÎÏ ÎÎÏÎÎÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÎÎÎ ÎÎÎÎÎÎ ÏÎÎ ÎÏÎÎÏÎÏÎ ÎÎÎ ÏÏÎÎÎÎÏÎ (ÏÏÏÏ "
+"ÎÎÎÎ ÎÎÎ ÏÎÏÎÎÎÏÎ ÎÎÏÎÏÎÏÎ)."
+
+#: C/image-viewer.c.page:74(p) C/guitar-tuner.c.page:79(p)
+msgid ""
+"The <code>ENABLE_NLS</code> conditional definition sets up <code>gettext</"
+"code>, which is a framework for translating applications. These functions "
+"specify how translation tools should handle your app when you run them."
+msgstr ""
+"Î ÏÏÏ ÏÏÎÏÏ ÎÏÎÏÎÏÏ <code>ENABLE_NLS</code> ÎÎÎÎÎÎÏÏÎ <code>gettext</code>, "
+"ÏÎÏ ÎÎÎÎÎ Î ÏÎÎÎÎÏÏÏ ÎÎÎ ÎÎÏÎÏÏÎÏÎ ÎÏÎÏÎÎÎÏÎ. ÎÏÏÎÏ ÎÎ ÏÏÎÎÏÏÎÏÎÎÏ ÎÏÎÎÎÏÎ "
+"ÏÏÏ ÏÎ ÎÏÎÎÎÎÎÎ ÎÎÏÎÏÏÎÏÎÏ ÎÎ ÏÎÎÏÎÏÏÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ ÏÏÎÎ ÏÎÏ "
+"ÎÎÏÎÎÎÎÏÎ."
+
+#: C/image-viewer.c.page:84(p)
+msgid ""
+"Now we will bring life into the empty window. GTK organizes the user "
+"interface with <code>GtkContainer</code>s that can contain other widgets and "
+"even other containers. Here we will use the simplest available container, a "
+"<code>GtkBox</code>:"
+msgstr ""
+"ÎÏÏÎ ÎÎÎÎÏÎÎ ÎÏÎ ÏÏÎ ÎÎÎÎÎ ÏÎÏÎÎÏÏÎ. ÎÎ GTK ÎÏÎÎÎÏÎÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÎÎ "
+"<code>GtkContainer</code> ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÎÎ "
+"ÎÎÏÎÎ ÎÎÎÎÏÏ ÏÎÏÎÎÎÏÎÏ. ÎÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎÎ ÎÏÎÎÏÏÏÎÏÎ ÎÎÎÎÎÏÎÎÎ "
+"ÏÎÏÎÎÎÏÎ, ÎÎÎÎ <code>GtkBox</code>:"
+
+#: C/image-viewer.c.page:122(p)
+msgid ""
+"The first lines create the widgets we want to use: a button for opening up "
+"an image, the image view widget itself and the box we will use as a "
+"container. The macros like <code>GTK_BOX</code> are used for dynamic type "
+"checking and casting which is needed as C doesn't support object-orientation "
+"out-of-the-box."
+msgstr ""
+"ÎÎ ÏÏÏÏÎÏ ÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎ ÎÏÎÎÏÎÎÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÎÎ ÏÏÎÏÎ: ÎÎÎ "
+"ÎÎÏÎÏÎ ÎÎÎ ÎÎÎÎÎÎÎ ÎÎÎÏ ÎÎÎÏÎÎÏ, ÏÎ ÎÎÎÎ ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÏÎÎÎÎÎÏ ÏÎÏ "
+"ÎÎÎÏÎÎÏ ÎÎÎ ÏÎ ÏÎÎÎÏÎÎ ÏÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÏ ÏÎÏÎÎÎÏÎ. ÎÎ ÎÎÎÏÎÎÎÏÎÎÎÏ "
+"ÏÏÏÏ <code>GTK_BOX</code> ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÎÎÎÎÏÎ ÎÏÎÎÎÎÎÎÏ ÏÏÏÎÏ ÎÎÎ "
+"ÎÎÎÎÎÎÏ ÏÎÏ ÎÏÎÎÏÎÏÎÏÎÎ ÎÎÎÏÏ Î C ÎÎÎ ÏÏÎÏÏÎÏÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏ "
+"ÎÎÏÎÎÎÎÎÎÎÎÏ ÎÎÏÏÏ ÏÎÎÎÏÎÎÏ."
+
+#: C/image-viewer.c.page:127(p)
+msgid ""
+"The calls to <code>gtk_box_pack_start</code> add the two widgets to the box "
+"and define their behaviour. The image will expand into any available space "
+"while the button will just be as big as needed. You will notice that we "
+"don't set explicit sizes on the widgets. In GTK this is usually not needed "
+"as it makes it much easier to have a layout that looks good in different "
+"window sizes. Next, the box is added to the window."
+msgstr ""
+"ÎÎ ÎÎÎÏÎÎÏ ÏÏÎ <code>gtk_box_pack_start</code> ÏÏÎÏÎÎÏÎÏÎ ÏÎ ÎÏÎ ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ ÏÏÎ ÏÎÎÎÏÎÎ ÎÎÎ ÎÏÎÎÎÏÎ ÏÎ ÏÏÎÏÎÏÎÏÎÏÎ ÏÎÏÏ. Î ÎÎÎÏÎÎ ÎÎ ÎÏÎÎÏÎÎÎÎ "
+"ÏÎ ÎÎÎÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ, ÎÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎ ÎÎÎÎÎ ÎÏÎÎ ÏÏÏÎ ÎÎÎÎÎÎ ÏÏÎ "
+"ÏÏÎÎÎÎÎÏÎÎ. ÎÎ ÏÎÏÎÏÎÏÎÏÎÏÎ ÏÏÎ ÎÎÎ ÎÏÎÎÎÏÎÎ ÏÎÏÎ ÎÎÎÎÎÎ ÏÏÎ ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ. ÎÏÎ GTK ÎÏÏÏ ÏÏÎÎÎÏÏ ÎÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÏÎÎÎÎ ÎÎÎÎÎ ÏÎÎ ÎÏÎÏ ÎÎ "
+"ÎÏÎÏÎ ÎÎÎ ÎÎÎÏÎÎÎ ÏÎÏ ÏÎÎÎÎÏÎÎ ÎÎÎÎ ÎÎ ÎÎÎÏÎÏÎÏÎÎÎ ÎÎÎÎÎÎ ÏÎÏÎÎÏÏÏÎ. ÎÏÎ "
+"ÏÏÎÎÏÎÎÎ, ÏÎ ÏÎÎÎÏÎÎ ÏÏÎÏÏÎÎÎÏÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ."
+
+#: C/image-viewer.c.page:133(p)
+msgid ""
+"We need to define what happens when the user clicks on the button. GTK uses "
+"the concept of <em>signals</em>. When the button is clicked, it fires the "
+"<em>clicked</em> signal, which we can connect to some action. This is done "
+"using the <code>g_signal_connect</code> function which tells GTK to call the "
+"<code>on_image_open</code> function when the button is clicked and to pass "
+"the image as an additional argument to that function. We will define the "
+"<em>callback</em> in the next section."
+msgstr ""
+"ÎÏÎÎÎÎÏÎÎÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎÎÎÎÎ ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎ ÏÎ ÎÎÎ ÏÎÎÎÏÏÎ. ÎÎ "
+"GTK ÏÏÎÏÎÎÎÏÎÎÎÎ ÏÎÎ ÎÎÎÎÎÎ ÏÏÎ <em>ÏÎÎÎÏÏÎ</em>. ÎÏÎÎ ÏÎ ÎÎÏÎÏÎ ÏÎÏÎÎÏÎÎ, "
+"ÎÎÎÎÎÎ ÏÎ ÏÎÎÎ <em>ÏÎÏÎÎÎÎÎ</em>, ÏÎÏ ÎÏÎÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÎÎ ÎÎÏÎÎÎ "
+"ÎÎÎÏÎÎÎÎ. ÎÏÏÏ ÎÎÎÎÏÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÏÏÎÎÏÏÎÏÎ "
+"<code>g_signal_connect</code> ÏÎÏ ÎÎÎÎ ÏÏÎ GTK ÎÎ ÎÎÎÎÏÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ "
+"<code>on_open_image</code> ÏÏÎÎ ÏÎ ÎÎÏÎÏÎ ÏÎÏÎÎÏÎÎ ÎÎÎ ÎÎ ÏÎÏÎÏÎÎ ÏÎÎ ÎÎÎÏÎÎ "
+"ÏÏ ÏÏÏÏÎÎÏÎ ÏÏÎÏÎÎ ÏÎ ÎÏÏÎ ÏÎ ÏÏÎÎÏÏÎÏÎ. ÎÎ ÎÏÎÏÎÏÎÎ ÏÎÎ "
+"<em>ÎÏÎÎÎÎÎÎÏÎ</em> ÏÏÎÎ ÎÏÏÎÎÎÎ ÎÎÏÏÎÏÎ."
+
+#: C/image-viewer.c.page:138(p)
+msgid ""
+"The last <code>g_signal_connect()</code> makes sure that the application "
+"exits when the window is closed."
+msgstr ""
+"Î ÏÎÎÎÏÏÎÎÎÏ <code>g_signal_connect()</code> ÎÏÎÎÎÎÎÎÏÎÎÎ ÏÏÎ Î ÎÏÎÏÎÎÎÎ "
+"ÏÎÏÎÎÎ ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÎÎ."
+
+#: C/image-viewer.c.page:141(p)
+msgid ""
+"As a last step, make sure to replace the <code>gtk_widget_show</code> call "
+"in the <code>main()</code> function by <code>gtk_widget_show_all()</code> to "
+"show the window and all the widgets it contains."
+msgstr ""
+"ÎÏ ÏÎÎÎÏÏÎÎÎ ÎÎÎÎ, ÎÎÎÎÎÏÎÎÎÏÎ ÎÎ ÎÎÏÎÎÎÏÎÏÏÎÏÎÏÎ ÏÎÎ ÎÎÎÏÎ "
+"<code>gtk_widget_show</code> ÏÏÎ ÏÏÎÎÏÏÎÏÎ <code>main()</code> ÎÏÏ "
+"<code>gtk_widget_show_all()</code> ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎ ÏÎÎ ÏÎ "
+"ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÎÏ ÏÎÏÎÎÏÎÎ."
+
+#: C/image-viewer.c.page:149(p)
+msgid ""
+"We will now define the signal handler for the <em>clicked</em> signal or the "
+"button we mentioned before. Add this code before the <code>create_window()</"
+"code> method."
+msgstr ""
+"ÎÎ ÎÏÎÏÎÏÎÎ ÏÏÏÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÎÏ ÎÎÎ ÏÎ ÏÎÎÎ <em>ÏÎÏÎÎÎÎÎ</em> Î ÎÎÎ ÏÎ "
+"ÎÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÏÎÎÎ ÏÏÎÎ. ÎÏÎÏÎÎÏÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÏÎÎ ÏÎ ÎÎÎÎÎÎ "
+"<code>create_window()</code>."
+
+#: C/image-viewer.c.page:187(p)
+msgid ""
+"The first argument of the signal is always the widget that sent the signal. "
+"Sometimes other arguments related to the signal come after that, but "
+"<em>clicked</em> doesn't have any. Next is the <code>user_data</code> "
+"argument which is a pointer to the data we passed when connecting the "
+"signal. In this case it is our <code>GtkImage</code> object."
+msgstr ""
+"ÎÎ ÏÏÏÏÎ ÏÏÎÏÎÎ ÏÎÏ ÏÎÎÎÏÎÏ ÎÎÎÎÎ ÏÎÎÏÎÏÎ ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ ÎÏÏÎÎÎÎ "
+"ÏÎ ÏÎÎÎ. ÎÎÏÎÎÎÏ ÏÎÏÎÏ ÎÎÎÎ ÎÏÎÏÎÎÏÎ ÏÏÎÏÎÎÎ ÎÎ ÏÎ ÏÎÎÎ ÎÏÏÎÎÏÎÎ ÎÎÏÎ ÎÏÏ "
+"ÎÏÏÏ, ÎÎÎÎ ÏÎ <em>ÏÎÏÎÎÎÎÎ</em> ÎÎÎ ÎÏÎÎ. ÎÏÏÎÎÎÎ ÏÏÎÏÎÎ ÎÎÎÎÎ ÏÎ "
+"<code>user_data</code> ÏÎÏ ÎÎÎÎÎ ÎÎÎÏ ÎÎÎÎÏÎÏ ÏÏÎ ÎÎÎÎÎÎÎÎ ÏÎÏ ÏÎÏÎÏÎÎÎ ÏÏÎÎ "
+"ÏÏÎÎÎÏÎÎÎ ÏÎ ÏÎÎÎ. ÎÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÎÎÎ ÏÎ ÎÎÏÎÎÎÎÎÎÎÏ ÎÎÏ "
+"<code>GtkImage</code>."
+
+#: C/image-viewer.c.page:193(p)
+msgid ""
+"The next interesting line is where the dialog for choosing the file is "
+"created using <code>gtk_file_chooser_dialog_new</code>. The function takes "
+"the title of the dialog, the parent window of the dialog and several options "
+"like the number of buttons and their corresponding values."
+msgstr ""
+"Î ÎÏÏÎÎÎÎ ÎÎÎÎÎÏÎÏÎÏÏÎ ÎÏÎÎÎÎ ÎÎÎÎÎ ÏÏÎÎ Î ÎÎÎÎÎÎÎÏ ÎÏÎÎÎÎÎÏ ÏÎÏ ÎÏÏÎÎÎÏ "
+"ÎÎÎÎÎÏÏÎÎÎÏÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ <code>gtk_file_chooser_dialog_new</code>. Î "
+"ÏÏÎÎÏÏÎÏÎ ÏÎÎÏÎÎÎ ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎÎÏÎÎÏ, ÏÎ ÎÎÎÏÎ ÏÎÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ "
+"ÎÎÎ ÏÎÎÎÎÏ ÎÏÎÎÎÎÎÏ ÏÏÏÏ Î ÎÏÎÎÎÏÏ ÏÏÎ ÎÎÏÎÏÎÏÎ ÎÎÎ ÎÎ ÎÎÏÎÏÏÎÎÏÎÏ ÏÎÎÎÏ "
+"ÏÎÏÏ."
+
+#: C/image-viewer.c.page:200(p)
+#| 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."
+msgid ""
+"The next two lines restrict the <gui>Open</gui> dialog to only display files "
+"which can be opened by GtkImage. A filter object is created first; we then "
+"add all kinds of files supported by <code>GdkPixbuf</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>ÎÎÎÎÎÎÎ</gui> ÎÎ "
+"ÎÎÏÎÎÎÎÎÎ ÎÏÎÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÏÎÎÏÎ ÎÏÏ ÏÎ GtkImage. ÎÎÎ "
+"ÎÎÏÎÎÎÎÎÎÎÎ ÏÎÎÏÏÎÏ ÎÎÎÎÎÏÏÎÎÎÏÎÎ ÏÏÏÏÎÂ ÎÏÎÎÏÎ ÏÏÎÏÎÎÏÎÏÎÎ ÏÎÎ ÏÎ ÎÎÎÎ ÏÏÎ "
+"ÎÏÏÎÎÏÎ ÏÎÏ ÏÏÎÏÏÎÏÎÎÎÎÏÎÎ ÎÏÏ <code>GdkPixbuf</code> (ÏÎÏ ÏÎÏÎÎÎÎÎÎÎÎÎ ÏÎÏ "
+"ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÎÏÏÎÏ ÏÏÏÏ PNG ÎÎÎ JPEG) ÏÏÎ ÏÎÎÏÏÎ. ÎÎÎÎÏ, ÎÏÎÎÎÏÎÎ ÎÏÏÏ ÏÎ "
+"ÏÎÎÏÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ <gui>ÎÎÎÎÎÎÎ</gui>."
+
+#: C/image-viewer.c.page:203(p)
+#| 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."
+msgid ""
+"<code>gtk_dialog_run</code> displays the <gui>Open</gui> dialog. The dialog "
+"will wait for the user to choose an image; when they do, "
+"<code>gtk_dialog_run</code> will return the value <code>GTK_RESPONSE_ACCEPT</"
+"code> (it would return <code>GTK_RESPONSE_CANCEL</code> if the user clicked "
+"<gui>Cancel</gui>). The <code>switch</code> statement tests for this."
+msgstr ""
+"Î <code>gtk_dialog_run</code> ÎÎÏÎÎÎÎÎÎ ÏÎ ÎÎÎÎÎÎÎ <gui>ÎÎÎÎÎÎÎ</gui>. Î "
+"ÎÎÎÎÎÎÎÏ ÎÎ ÏÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎÂ ÏÏÎÎ ÎÎÎÎÎÎÎÎ, Î "
+"<code>gtk_dialog_run</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÎÎ ÏÎÎÎ "
+"<code>GTK_RESPONSE_ACCEPT</code> (ÎÎ ÎÏÎÏÏÏÎÏÎÎ "
+"<code>GTK_RESPONSE_CANCEL</code> ÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎÎ <gui>ÎÎÏÏÏÏÎ</gui>). Î "
+"ÏÏÏÏÎÏÎ <code>switch</code> ÎÎÎÎÏÎÎ ÎÎÎ ÎÏÏÏ."
+
+#: C/image-viewer.c.page:205(p)
+#| 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."
+msgid ""
+"Assuming that the user did click <gui>Open</gui>, the next line sets the "
+"<code>file</code> property of the GtkImage to the filename of the image "
+"selected by the user. The GtkImage will then load and display the chosen "
+"image."
+msgstr ""
+"ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎ ÏÎ <gui>ÎÎÎÎÎÎÎ</gui>, Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ "
+"ÎÏÎÎÎÎ ÏÎÎ ÎÎÎÏÏÎÏÎ <code>file</code> ÏÎÏ GtkImage ÏÏÎ ÏÎÎÎÎ ÏÎÏ ÎÏÏÎÎÎÏ "
+"ÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎÎ Î ÏÏÎÏÏÎÏ. ÎÎ GtkImage ÎÎ ÏÎÏÏÏÏÎÎ ÏÏÏÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ "
+"ÏÎÎ ÎÏÎÎÎÎÎÎÎÎ ÎÎÎÏÎÎ."
+
+#: C/image-viewer.c.page:208(p)
+#| msgid ""
+#| "In the final line of this method, we destroy the <gui>Open</gui> dialog "
+#| "because we don't need it any more."
+msgid ""
+"In the final line of this method, we destroy the <gui>Open</gui> dialog "
+"because we don't need it any more. Destroying automatically hides the dialog."
+msgstr ""
+"ÎÏÎÎ ÏÎÎÎÏÏÎÎÎ ÎÏÎÎÎÎ ÎÏÏÎÏ ÏÎÏ ÎÎÎÏÎÎÏ, ÎÎÏÎÏÏÏÎÏÎÏÎÎ ÏÎÎ ÎÎÎÎÎÎÎ "
+"<gui>ÎÎÎÎÎÎÎ</gui> ÎÎÎÏÎ ÎÎÎ ÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎ ÏÎÎ. ÎÎÏÎÏÏÏÎÏÎÎÏÎÏ ÏÎÎ "
+"ÎÏÏÏÎÎÏÎ ÎÏÏÎÎÏÎÎ Î ÎÎÎÎÎÎÎÏ."
+
+#: C/image-viewer.c.page:222(p)
+#| msgid ""
+#| "If you run into problems with the tutorial, compare your code with this "
+#| "<link href=\"image-viewer/image-viewer.py\">reference code</link>."
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"image-viewer/image-viewer.c\">reference code</link>."
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ "
+"ÏÎÎ <link href=\"image-viewer/image-viewer.c\">ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/image.vala.page:20(None) C/image.py.page:20(None) C/image.c.page:20(None)
+#| msgid ""
+#| "@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+msgid "@@image: 'media/image.png'; md5=9416aa74d9d6a857783f7a36338e7a02"
+msgstr "@@image: 'media/image.png'Â md5=9416aa74d9d6a857783f7a36338e7a02"
+
+#: C/image.vala.page:16(desc) C/image.py.page:16(desc)
+msgid "A widget displaying an image"
+msgstr "ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ"
+
+#: C/image.vala.page:19(title) C/image.py.page:19(title)
+#: C/image.c.page:19(title)
+msgid "Image"
+msgstr "ÎÎÎÏÎÎ"
+
+#: C/image.vala.page:21(p) C/image.py.page:21(p) C/image.c.page:21(p)
+msgid "This GtkApplication displays an image file from the current directory."
+msgstr ""
+"ÎÏÏÎ Î GtkApplication ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ ÎÏÏ ÏÎÎ ÏÏÎÏÎÎÏÎ "
+"ÎÎÏÎÎÎÎÎ."
+
+#: C/image.vala.page:22(p) C/image.py.page:22(p) C/image.c.page:22(p)
+msgid ""
+"If the image file isn't loaded successfully, the image will contain a "
+"\"broken image\" icon. The <file>filename.png</file> needs to be in the "
+"current directory for this code to work. Use your favorite picture!"
+msgstr ""
+"ÎÎÎ ÏÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ ÎÎÎ ÏÎÏÏÏÎÎÎ ÎÏÎÏÏÏÏÏ, Î ÎÎÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎ "
+"ÎÎÎÎÎÎÎÎÎ \"ÏÏÎÏÎÎÎÎÏ ÎÎÎÏÎÎÏ\". ÎÎ <file>filename.png</file> ÏÏÎÎÎÎÎÏÎÎ ÎÎ "
+"ÎÎÎÎÎ ÏÏÎÎ ÏÏÎÏÎÎÏÎ ÎÎÏÎÎÎÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÏÎÎ ÎÏÏÏÏ Î ÎÏÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ "
+"ÏÎÎ ÎÎÎÏÎÎÎÎÎ ÏÎÏ ÎÎÎÏÎÎ!"
+
+#: C/image.vala.page:31(link) C/GtkApplicationWindow.py.page:29(link)
+#: C/GtkApplicationWindow.c.page:29(link) C/checkbutton.py.page:29(link)
+#: C/aboutdialog.py.page:30(link)
+#| msgid "A first Gtk application"
+msgid "GtkApplicationWindow"
+msgstr "GtkApplicationWindow"
+
+#: C/image.c.page:16(desc)
+msgid "A widget displaying an image."
+msgstr "ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÏ ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ."
+
+#: C/helloworldautotools.js.page:18(title)
+msgid "Autotools files for your Hello World application"
+msgstr "ÎÏÏÎÎÎ Autotools ÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ Hello World"
+
+#: C/helloworldautotools.js.page:19(p)
+msgid ""
+"To make your application truly a part of the GNOME 3 system you need to "
+"install it with the help of autotools. The autotools build will install all "
+"the necessary files to all the right places."
+msgstr ""
+"ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ ÏÏÎÎÎÎÏÎÎÎ ÏÎÎÎÎ ÏÎÏ ÏÏÏÏÎÎÎÏÎÏ GNOME 3 "
+"ÏÏÎÎÎÎÏÏÎÏÏÎ ÏÎÎ ÎÎÎÎÏÎÏÏÎÏÎ ÏÎÏ ÎÎ ÏÎ ÎÎÎÎÎÎÎ ÏÏÎ autotools. Î ÎÎÏÎÏÎÎÏÎ "
+"ÏÏÎ autotools ÎÎ ÎÎÎÎÏÎÏÏÎÏÎÎ ÏÎÎ ÏÎ ÎÏÎÏÎÎÏÎÏÎ ÎÏÏÎÎÎ ÏÎ ÏÎÎÏ ÏÎÏ ÏÏÏÏÎÏ "
+"ÎÎÏÎÎÏ."
+
+#: C/helloworldautotools.js.page:20(p)
+msgid "For this you need to have the following files:"
+msgstr "ÎÎÎ ÎÏÏÏ ÏÏÎÎÎÎÏÏÎÏÏÎ ÎÎ ÎÏÎÏÎ ÏÎ ÏÎÏÎÎÎÏÏ ÎÏÏÎÎÎ:"
+
+#: C/helloworldautotools.js.page:25(p)
+msgid "README"
+msgstr "README"
+
+#: C/helloworldautotools.js.page:32(p)
+msgid "autogen.sh file will install"
+msgstr "ÏÎ ÎÏÏÎÎÎ autogen.sh ÏÎÏ ÎÎ ÎÎÎÎÏÎÏÏÎÏÎÎ"
+
+#: C/helloworldautotools.js.page:33(p)
+msgid "After the autogen.sh file is ready and saved run"
+msgstr "ÎÎÏÎ ÏÎ ÎÏÏÎÎÎ autogen.sh ÎÎÎÎÎ ÎÏÎÎÎÎ ÎÎÎ ÎÏÎÎÎÎÎÏÎÎÎÎ ÎÎ ÏÏÎÎÎÎ"
+
+#: C/helloworldautotools.js.page:33(input)
+msgid "chmod +x autogen.sh"
+msgstr "chmod +x autogen.sh"
+
+#: C/helloworldautotools.js.page:33(p)
+msgid "to give the file the necessary rights to install."
+msgstr "ÎÎ ÎÏÏÎÏÎ ÏÏÎ ÎÏÏÎÎÎ ÏÎ ÎÏÎÏÎÎÏÎÏÎ ÎÎÎÎÎÏÎÎÏÎ ÎÎÎ ÎÎÎÎÏÎÏÏÎÏÎ."
+
+#: C/helloworldautotools.js.page:52(p)
+msgid "README: Information user should read first."
+msgstr "README: ÎÎ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏÏÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÏÎ ÏÏÏÏÎ."
+
+#: C/helloworldautotools.js.page:53(p)
+msgid ""
+"When you have all the 3 files with correct information and rights run these "
+"commands in terminal:"
+msgstr ""
+"ÎÏÎÎ ÎÏÎÏÎ ÎÎÎ ÏÎ 3 ÎÏÏÎÎÎ ÎÎ ÏÏÏÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÎÎÎ ÎÎÎÎÎÏÎÎÏÎ ÏÏÎÎÏÎ ÎÏÏÎÏ "
+"ÏÎÏ ÎÎÏÎÎÎÏ ÏÎ ÏÎÏÎÎÏÎÎÏ:"
+
+#: C/helloworldautotools.js.page:55(input)
+msgid "./autogen.sh"
+msgstr "./autogen.sh"
+
+#: C/helloworldautotools.js.page:56(input)
+msgid "./configure --prefix=/usr/local"
+msgstr "./configure --prefix=/usr/local"
+
+#: C/helloworldautotools.js.page:57(input)
+msgid "sudo make install"
+msgstr "sudo make install"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/helloWorld.js.page:32(None)
+msgid "@@image: 'media/helloWorldJs.png'; md5=4c88a27211dfd1b33e504c9f78602f2d"
+msgstr "@@image: 'media/helloWorldJs.png'Â md5=4c88a27211dfd1b33e504c9f78602f2d"
+
+#: C/helloWorld.js.page:15(desc)
+msgid "A basic \"hello, world\" application"
+msgstr "ÎÎÎ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎÎ \"hello, world\""
+
+#: C/helloWorld.js.page:17(title)
+msgid "Hello World"
+msgstr "Hello World"
+
+#: C/helloWorld.js.page:20(p)
+msgid ""
+"In this tutorial we'll construct a small application, Hello World, using "
+"JavaScript and GTK+. To write and run all the code examples yourself, you "
+"need an editor to write code in, Terminal, and GNOME 3 or higher installed "
+"into your computer. In this tutorial we'll go through the following parts:"
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎÎ ÎÎÎ ÎÎÎÏÎ ÎÏÎÏÎÎÎÎ, Hello World, "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ JavaScript ÎÎÎ GTK+. ÎÎÎ ÎÎ ÎÏÎÏÎÏÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎ ÏÎÎ ÏÎ "
+"ÏÎÏÎÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ ÎÎ ÎÎÎÎÎ, ÏÏÎÎÎÎÏÏÎÏÏÎ ÎÎÎÎ ÎÏÎÎÎÏÎÎÏÏÎ ÎÎÎ ÏÎ ÎÏÎÏÎÎÎ "
+"ÏÎÏ ÎÏÎÎÎÎ, ÏÎÏÎÎÏÎÎÏ ÎÎÎ GNOME 3 Î ÎÎÏÎÎÎÎÎÏÏÎÏÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÏÏÎÎ "
+"ÏÏÎÎÎÎÎÏÏÎ ÏÎÏ. ÎÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ ÎÎ ÎÎÎÏÎÏÎÏÎÎ ÏÎ ÏÎÏÎÎÎÏÏ ÎÎÏÎ:"
+
+#: C/helloWorld.js.page:25(link) C/helloWorld.js.page:64(title)
+msgid "Label for the window"
+msgstr "ÎÏÎÎÎÏÎ ÎÎÎ ÏÎ ÏÎÏÎÎÏÏÎ"
+
+#: C/helloWorld.js.page:26(link) C/helloWorld.js.page:80(title)
+msgid "helloWorld.js"
+msgstr "helloWorld.js"
+
+#: C/helloWorld.js.page:27(link) C/guitar-tuner.js.page:31(link)
+#: C/guitar-tuner.js.page:228(title)
+#| msgid "Run the application"
+msgid "Running the application form Terminal"
+msgstr "ÎÏÎÎÎÎÎ ÏÎÏ ÎÏÎÏÎÎÎÎÏ ÎÏÏ ÏÎÏÎÎÏÎÎÏ"
+
+#: C/helloWorld.js.page:31(p)
+msgid "After taking this tutorial, you should see this on your screen:"
+msgstr ""
+"ÎÎÏÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÎÏÏÎÏ ÏÎÏ ÎÎÎÎÎÎÏÎÏ, ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÏÏÏ ÏÏÎÎ ÎÎÏÎÎ "
+"ÏÎÏ:"
+
+#: C/helloWorld.js.page:37(p)
+msgid ""
+"This needs to be the first line of your script, because it tells GNOME that "
+"we'll be using Gjs -- the JavaScript bindings for GNOME -- in order to run "
+"it."
+msgstr ""
+"ÎÏÏÏ ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÎÎÎÎ Î ÏÏÏÏÎ ÎÏÎÎÎÎ ÏÎÏ ÏÎÎÎÏÎÎÏ ÏÎÏ, ÎÏÎÎÎÎ ÎÎÎÎ ÏÏÎ "
+"GNOME ÏÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ Gjs -- ÏÎÏÏ ÏÏÎÎÎÏÎÎÏÏ JavaScript ÎÎÎ GNOME -- "
+"ÎÎÎ ÎÎ ÏÎ ÏÏÎÎÎÎ."
+
+#: C/helloWorld.js.page:44(p)
+msgid ""
+"In order for our script to work with GNOME, we need to import GNOME "
+"libraries via GObject Introspection. In this case, we're importing GTK+, the "
+"most basic library that contains the graphical widgets used to make GNOME "
+"apps."
+msgstr ""
+"ÎÎÎ ÎÎ ÎÎÏÎÎÏÎÎ ÏÎ ÏÎÎÎÏÎÏ ÎÎÏ ÎÎ GNOME, ÏÏÎÎÎÎÏÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎÏ "
+"ÎÎÎÎÎÎÎÎÎÎÏ GNOME ÎÎÏÎ ÎÏÏ ÏÎÎ ÎÏÏÎÎÎÎÎÏÎ GObject. ÎÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ, "
+"ÎÎÏÎÎÎÏÎÎ GTK+, ÏÎÎ ÏÎÎ ÎÎÏÎÎÎ ÎÎÎÎÎÎÎÎÎÎ ÏÎÏ ÏÎÏÎÎÏÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎÎÎ "
+"ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÎÎ ÏÎÎ ÎÎÏÎÏÎÎÏÎ ÎÏÎÏÎÎÎÏÎ GNOME."
+
+#: C/helloWorld.js.page:60(p)
+msgid ""
+"After importing Gtk, we need to initialize it. After that, we can start "
+"building our first window. We do this by creating a variable called mywindow "
+"and assigning it a new Gtk.Window of type TOPLEVEL."
+msgstr ""
+"ÎÎÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ Gtk, ÏÏÎÎÎÎÏÎÎÏÏÎ ÎÎ ÏÎ ÎÏÏÎÎÎÏÎÎÎÏÎÏÎÎ. ÎÎÏÎ ÎÏÏ ÎÏÏÏ, "
+"ÎÏÎÏÎÏÎÎ ÎÎ ÎÏÏÎÏÎÏÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎÎÎÏÎÎ ÏÎ ÏÏÏÏÎ ÎÎÏ ÏÎÏÎÎÏÏÎ. ÎÏÏÏ ÏÎ "
+"ÎÎÎÎÏÎÎ ÎÎÎÎÎÏÏÎÏÎÏÎÏ ÎÎÎ ÎÎÏÎÎÎÎÏÎ ÏÎÏ ÎÎÎÎÏÎÎ mywindow ÎÎÎ ÏÎÏ ÎÏÎÎÎÎÎÏÎÎ "
+"ÎÎÎ ÎÎÎ Gtk.Window ÏÎÏ ÏÏÏÎÏ TOPLEVEL."
+
+#: C/helloWorld.js.page:60(p)
+msgid ""
+"After setting up our first window we'll give the window a property called "
+"title. The title can be any string you want it to be. To be on the safe "
+"side, it's best to stick to UTF-8 encoding."
+msgstr ""
+"ÎÎÏÎ ÏÎÎ ÎÎÎÎÏÎÏÏÎÏÎ ÏÎÏ ÏÏÏÏÎÏ ÎÎÏ ÏÎÏÎÎÏÏÎÏ ÎÎ ÎÏÏÎÏÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎ "
+"ÎÎÎÏÏÎÏÎ ÏÎÏ ÎÎÎÎÏÎÎ ÏÎÏÎÎÏ. Î ÏÎÏÎÎÏ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÏÎÎÎÎÎÏÎÏÎ ÎÏÎÎÏÎÎÏÎ "
+"ÏÏÎÎÎÎÎÏÎÎÏÎ. ÎÎÎ ÎÎ ÎÎÏÎÏÏÎ ÎÏÏÎÎÎÎÏ, ÎÎÎÎÎ ÎÎÎÏÏÎÏÎ ÎÎ ÎÏÎÎÎÎÎÏÎ ÏÎÎ "
+"ÎÏÎÎÎÎÏÎÎÎÏÎ UTF-8."
+
+#: C/helloWorld.js.page:60(p)
+msgid ""
+"The next thing we need to do for our application is connect the close button "
+"that's automatically generated along with the window to the close "
+"functionality. That happens with the method connect(). When the close button "
+"is pressed it gives out the signal \"destroy\", so in this part we're "
+"connecting the \"destroy\" signal to function(){Gtk.main_quit()}, which does "
+"the actual closing."
+msgstr ""
+"ÎÎ ÎÏÏÎÎÎÎ ÏÏÎÎÎÎ ÏÎÏ ÏÏÎÎÎÎÏÎÎÏÏÎ ÎÎ ÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÎÎÏ ÎÎÎÎÎ ÎÎ "
+"ÏÏÎÎÎÏÎÏÎÎ ÏÎ ÎÎÏÎÏÎ ÎÎÎÎÏÎÎÎ ÏÎÏ ÎÎÎÎÎÎÏÎÎ ÎÏÏÏÎÎÏÎ ÎÎÎÎ ÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÏÏÎ "
+"ÎÎÎÏÎÏÏÎÎÎÏÏÎÏÎ ÎÎÎÎÏÎÎÎÏÎÏ. ÎÏÏÏ ÏÏÎÎÎÎÎÎÎ ÎÎ ÏÎ ÎÎÎÎÎÎ connect(). ÎÏÎÎ ÏÎ "
+"ÎÎÏÎÏÎ ÎÎÎÎÏÎÎÎÏÎÏ ÏÎÏÎÎÏÎÎ ÎÎÏÎÎÏÎÎ ÏÎ ÏÎÎÎ \"destroy\", ÎÏÏÎ ÏÎ ÎÏÏÏ ÏÎ "
+"ÏÎÎÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎ \"destroy\" ÏÏÎ function(){Gtk.main_quit()}, ÏÎÏ ÎÎÎÎÎ "
+"ÏÎ ÎÎÎÏÎÏ ÎÎÎÎÏÎÎÎ."
+
+#: C/helloWorld.js.page:60(p)
+msgid ""
+"Now we have a window that has a title and a working \"close\" button. Let's "
+"add the actual \"Hello, world\" text."
+msgstr ""
+"ÎÏÏÎ ÎÏÎÏÎÎ ÎÎÎ ÏÎÏÎÎÏÏÎ ÏÎÏ ÎÏÎÎ ÏÎÏÎÎ ÎÎÎ ÎÎÎ ÎÎÎÏÎÏÏÎÎÎÏ ÎÎÏÎÏÎ \"close\". "
+"ÎÏ ÏÏÎÏÎÎÏÎÏÎÎ ÏÎ ÎÎÎÏÎÏ ÎÎÎÎÎÎÎ \"Hello, world\"."
+
+#: C/helloWorld.js.page:76(p)
+msgid ""
+"A text label is one of the GTK+ widgets we can use, on account of having "
+"imported the GTK+ library. To use it, we create a new variable called label, "
+"and assign it a new Gtk.Label. Then we give it properties inside the curly "
+"braces {}. In this case, we're setting the text that the label will hold. "
+"Finally, we tell GNOME to show the label and the window containing it to the "
+"user, and call Gtk.main() to get the app itself started."
+msgstr ""
+"ÎÎÎ ÎÏÎÎÎÏÎ ÎÎÎÎÎÎÎÏ ÎÎÎÎÎ ÎÎÎ ÎÏÏ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÎÏ GTK+ ÏÎÏ "
+"ÎÏÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ, ÎÏÎÏ ÏÎÏ ÎÎÏÎÎÏÎÎÏ ÏÎÏ ÎÎÎÎÎÎÎÎÎÎÏ GTK+. ÎÎÎ "
+"ÏÎ ÏÏÎÏÎ ÏÎÏ, ÎÎÎÎÎÏÏÎÎÏÎÎ ÎÎÎ ÎÎÎ ÎÎÏÎÎÎÎÏÎ ÏÎÏ ÎÎÎÎÎÎÎÏÎÎ ÎÏÎÎÎÏÎ ÎÎÎ ÏÎÏ "
+"ÎÏÎÎÎÎÎÏÎÎ ÎÎÎ ÎÎÎ Gtk.Label. ÎÏÎÎÏÎ ÏÎÏ ÎÎÎÎÏÎÎ ÎÎÎÏÏÎÏÎÏ ÎÎÏÎ ÏÎ ÎÎÎÏÎÎÏ "
+"{}. ÎÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ, ÎÏÎÎÎÏÎÎ ÏÎ ÎÎÎÎÎÎÎ ÏÎÏ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎÎ ÎÏÎÎÎÏÎ. "
+"ÎÎÎÎÎÎ, ÎÎÎÎ ÏÏÎ GNOME ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎÎ ÎÏÎÎÎÏÎ ÎÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÏÎÏ ÏÎÎ "
+"ÏÎÏÎÎÏÎÎ ÏÏÎ ÏÏÎÏÏÎ, ÎÎÎ ÎÎÎÎÏÎÎ ÏÎ Gtk.main() ÎÎ ÎÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎ ÏÎÎ "
+"ÎÏÎÏÎÎÎÎ."
+
+#: C/helloWorld.js.page:77(p)
+msgid ""
+"For the future, keep in mind that Gtk.Window can only hold one widget at a "
+"time. To construct more elaborate programs you need to create a holder "
+"widget (Gtk.Box, Gtk.Grid, Gtk.Application, and so on) of some kind inside "
+"the window, and then add all the other widgets to it."
+msgstr ""
+"ÎÎÎ ÏÎ ÎÎÎÎÎÎ, ÎÎ ÎÏÎÏÎÏÎÏÎ ÏÏÎ ÏÎ Gtk.Window ÎÏÎÏÎÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÏÎÎ ÎÎÎ "
+"ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎ ÏÎÏÎ. ÎÎÎ ÎÎÏÎÏÎÎÏÎ ÏÎÎ ÏÎÏÎÏÎÎÎÏÎ ÏÏÎÎÏÎÎÎÎÏÏÎ "
+"ÏÏÎÎÎÎÏÏÎÏÏÎ ÏÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÏÏ ÏÎÎÏÎÏÏÎ ÎÏÎÏÎÎÎÏ ÏÏÏÏÎÏÎÎÎÏ (Gtk.Box, "
+"Gtk.Grid, Gtk.Application Î.Î.Î) ÎÎÏÎÎÏÎ ÎÎÎÏÎ ÎÎÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎ ÎÏÎÎÏÎ "
+"ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÏÎÎ ÏÎ ÎÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÎ ÎÏÏÏ."
+
+#: C/helloWorld.js.page:81(p)
+msgid "Here's what the completed program looks like."
+msgstr "ÎÎ ÏÏÏ ÏÎÎÎÎÏÎÎ ÏÎ ÏÎÎÏÎÏ ÏÏÏÎÏÎÎÎÎ."
+
+#: C/helloWorld.js.page:109(title)
+#| msgid "Run the application"
+msgid "Running the application from Terminal"
+msgstr "ÎÏÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÎÏÏ ÏÎÏÎÎÏÎÎÏ"
+
+#: C/helloWorld.js.page:110(p)
+msgid ""
+"To run this application, first save it as helloWorld.js. Then open Terminal, "
+"go to the folder where your application is stored and run"
+msgstr ""
+"ÎÎÎ ÎÎ ÏÏÎÎÎÏÎ ÎÏÏÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ, ÏÏÏÏÎ ÎÏÎÎÎÎÎÏÏÏÎ ÏÎÎ ÏÏ helloWorld.js. "
+"ÎÏÎÎÏÎ ÎÎÎÎÎÏÎ ÏÎÎ ÏÎÏÎÎÏÎÎÏ, ÏÎÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎÎÎ ÏÏÎÏ Î ÎÏÎÏÎÎÎÎ ÏÎÏ "
+"ÎÏÎÎÎÎÎÏÎÏÎ ÎÎÎ ÏÏÎÎÏÎ ÏÎÎ"
+
+#: C/helloWorld.js.page:110(input)
+msgid "chmod +x helloWorld.js"
+msgstr "chmod +x helloWorld.js"
+
+#: C/helloWorld.js.page:111(p)
+msgid "This makes your script executable. After that, run"
+msgstr "ÎÏÏÏ ÎÎÎÎÎ ÏÎ ÏÎÎÎÏÎÎ ÏÎÏ ÎÎÏÎÎÎÏÎÎÎ. ÎÎÏÎ ÎÏÏ ÎÏÏÏ ÏÏÎÎÏÎ ÏÎ"
+
+#: C/helloWorld.js.page:111(input)
+msgid "GJS_PATH=`pwd` gjs helloWorld.js"
+msgstr "GJS_PATH=`pwd` gjs helloWorld.js"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/guitar-tuner.vala.page:42(None) C/guitar-tuner.py.page:38(None)
+#: C/guitar-tuner.js.page:35(None) C/guitar-tuner.cpp.page:37(None)
+#: C/guitar-tuner.c.page:38(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner-pipeline.png'; "
+#| "md5=5adc952909d92af5dae6954781b4ad5f"
+msgid "@@image: 'media/guitar-tuner.png'; md5=35e615e0f5e293671d00c5c414ac2f6b"
+msgstr "@@image: 'media/guitar-tuner.png'Â md5=35e615e0f5e293671d00c5c414ac2f6b"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/guitar-tuner.vala.page:95(None) C/guitar-tuner.py.page:89(None)
+#: C/guitar-tuner.cpp.page:88(None) C/guitar-tuner.c.page:93(None)
+msgid ""
+"@@image: 'media/guitar-tuner-glade.png'; md5=f6606525443ab2160f53a87a454364d0"
+msgstr ""
+"@@image: 'media/guitar-tuner-glade.png'; md5=f6606525443ab2160f53a87a454364d0"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/guitar-tuner.vala.page:129(None) C/guitar-tuner.py.page:132(None)
+#: C/guitar-tuner.js.page:41(None) C/guitar-tuner.cpp.page:117(None)
+#: C/guitar-tuner.c.page:138(None)
+msgid ""
+"@@image: 'media/guitar-tuner-pipeline.png'; "
+"md5=5adc952909d92af5dae6954781b4ad5f"
+msgstr ""
+"@@image: 'media/guitar-tuner-pipeline.png'; "
+"md5=5adc952909d92af5dae6954781b4ad5f"
+
+#: C/guitar-tuner.vala.page:9(desc)
+#| msgid ""
+#| "Use Gtk+ and GStreamer to build a simple guitar tuner application for "
+#| "GNOME. Shows off how to use the interface designer."
+msgid ""
+"Use <link href=\"http://developer.gnome.org/platform-overview/stable/gtk";
+"\">Gtk+</link> and <link href=\"http://developer.gnome.org/platform-overview/";
+"stable/gstreamer\">GStreamer</link> to build a simple guitar tuner "
+"application for GNOME. Shows off how to use the interface designer."
+msgstr ""
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ <link href=\"http://developer.gnome.org/platform-";
+"overview/stable/gtk\">Gtk+</link> ÎÎÎ <link href=\"http://developer.gnome.org";
+"/platform-overview/stable/gstreamer\">GStreamer</link> ÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎ ÎÎÎ "
+"ÎÏÎÏ ÏÏÏÎÏÎÎÎÎ ÏÏÎÎÎÏÏÎ ÎÎÎÎÏÎÏ ÎÎÎ ÏÎ GNOME. ÎÎÎÎÎÎÎÎÏÎÎ ÏÏÏ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ."
+
+#: C/guitar-tuner.vala.page:26(title) C/guitar-tuner.py.page:22(title)
+#: C/guitar-tuner.js.page:18(title)
+#| msgid "Guitar Tuner"
+msgid "2 Guitar Tuner"
+msgstr "2 ÏÏÎÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ"
+
+#: C/guitar-tuner.vala.page:29(p)
+#| 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:"
+msgid ""
+"In this tutorial you will create an application which plays tones that you "
+"can use to tune a guitar. You will learn how to:"
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ, ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ ÏÎÎÎÎÎ ÏÏÎÎÏÏ ÎÎÎ "
+"ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎÎÎÏÎ. ÎÎ ÎÎÎÎÏÎ ÏÏÏ ÎÎ:"
+
+#: C/guitar-tuner.vala.page:31(p)
+#| msgid ""
+#| "An installed copy of the <link xref=\"getting-ready\">Anjuta IDE</link>"
+msgid ""
+"Set up a basic project using the <link xref=\"getting-ready\">Anjuta IDE</"
+"link>."
+msgstr ""
+"ÎÎÎÎÏÎÏÏÎÏÎÏÎ ÎÎÎ ÎÎÏÎÎÏ ÎÏÎÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ <link xref=\"getting-"
+"ready\">Anjuta IDE</link>."
+
+#: C/guitar-tuner.vala.page:32(p)
+#| msgid "Create a simple GUI with Anjuta's UI designer"
+msgid "Create a simple GUI with <app>Anjuta</app>'s UI designer."
+msgstr "ÎÎÎÎÎÏÏÎÎÏÏÎ ÎÎÎ ÎÏÎÏ GUI ÎÎ ÏÎÎ ÏÏÎÎÎÎÏÏÎ UI ÏÎÏ <app>Anjuta</app>."
+
+#: C/guitar-tuner.vala.page:33(p)
+msgid ""
+"Use the <link href=\"http://developer.gnome.org/platform-overview/stable/";
+"gstreamer\">GStreamer</link> library to play sounds."
+msgstr ""
+"ÎÏÎÏÎ ÏÎÏ ÎÎÎÎÎÎÎÎÎÎÏ <link href=\"http://developer.gnome.org/platform-";
+"overview/stable/gstreamer\">GStreamer</link> ÎÎÎ ÎÎ ÏÎÎÎÎÎ ÎÏÎÏÏ."
+
+#: C/guitar-tuner.vala.page:45(title)
+#| msgid "Create a project in Anjuta"
+msgid "Create a project in <app>Anjuta</app>"
+msgstr "ÎÎÎÎÎÏÏÎÎÏÏÎ ÎÎÎ ÎÏÎÎ ÎÎ ÏÎ <app>Anjuta</app>"
+
+#: C/guitar-tuner.vala.page:52(p)
+#| 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."
+msgid ""
+"Click on the <gui>Vala</gui> tab and select <gui>Gtk+ (Simple)</gui>. Click "
+"<gui>Continue</gui>, and fill out your details on the next few pages. Use "
+"<file>guitar-tuner</file> as project name and directory."
+msgstr ""
+"ÎÎÎÎ ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>Vala</gui> ÎÎÎ ÎÏÎÎÎÎÏÎ <gui>Gtk+ (ÎÏÎÏ)</gui>. ÎÎÎÎ "
+"<gui>ÏÏÎÎÏÎÎÎ</gui> ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ ÎÎÎÎÏ "
+"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÎÎÏÎÎÏÎÎÏ ÏÎ <file"
+">guitar-tuner</file>."
+
+#: C/guitar-tuner.vala.page:55(p)
+msgid ""
+"Make sure that <gui>Configure external packages</gui> is switched <gui>ON</"
+"gui>. On the next page, select <link href=\"http://valadoc.org/gstreamer-";
+"0.10/index.htm\"><em>gstreamer-0.10</em></link> from the list to include the "
+"GStreamer library in your project. Click <gui>Continue</gui>"
+msgstr ""
+"ÎÎÎÎÎÏÎÎÎÏÎ ÏÏÎ Î <gui>ÏÏÎÎÎÏÎ ÎÎÏÏÎÏÎÎÏÎ ÏÎÎÎÏÏÎ</gui> ÎÎÎÎÎ "
+"<gui>ÎÎÎÏÎÎ</gui>. ÎÏÎÎ ÎÏÏÎÎÎÎ ÏÎÎÎÎÎ, ÎÏÎÎÎÎÏÎ <link href=\"http://valadoc.";
+"org/gstreamer-0.10/index.htm\"><em>gstreamer-0.10</em></link> ÎÏÏ ÏÎ ÎÎÏÏÎ "
+"ÎÎÎ ÏÏÎÏÎÏÎÎÎÏÎ ÏÎÏ ÎÎÎÎÎÎÎÎÎÎÏ GStreamer ÏÏÎ ÎÏÎÎ ÏÎÏ. ÎÎÎÎ "
+"<gui>ÏÏÎÎÏÎÎÎ</gui>"
+
+#: C/guitar-tuner.vala.page:59(p)
+#| 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:"
+msgid ""
+"Click <gui>Apply</gui> and the project will be created for you. From the "
+"<gui>Project</gui> or <gui>Files</gui> tab, open <file>src/guitar_tuner."
+"vala</file> by double-clicking on it. You should see some code which starts "
+"with the lines:"
+msgstr ""
+"ÎÎÎÎ <gui>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÏÎÏ. ÎÏÏ ÏÎÏ "
+"ÎÎÏÏÎÎÎÏ <gui>ÎÏÎÎ</gui> Î <gui>ÎÏÏÎÎÎ</gui>, ÎÎÎÎÎÏÎ ÏÎ "
+"<file>src/guitar_tuner.vala</file> ÎÎ ÎÎÏÎÏ ÎÎÎÎ ÏÎÎÏ ÏÎÏ. ÎÎ ÏÏÎÏÎÎ ÎÎ "
+"ÎÎÎÏÎ ÎÎÏÎÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ ÏÎÏ ÎÏÎÎÎÎÏ:"
+
+#: C/guitar-tuner.vala.page:69(p)
+#| 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:"
+msgid ""
+"The code loads an (empty) window from the user interface description file "
+"and displays it. More details are given below; you may choose to skip this "
+"list if you understand the basics:"
+msgstr ""
+"Î ÎÏÎÎÎÎÏ ÏÎÏÏÏÎÎÎ ÎÎÎ (ÎÎÎÏ) ÏÎÏÎÎÏÏÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ ÏÎÏÎÎÏÎÏÎÏ ÎÎÎÏÎÏÎÏ "
+"ÏÏÎÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÎÎÎÎÎ. ÎÎÏÎÏÏÏÏÎÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÎÎÎÎÎÏÎÎ ÏÎÏÎÎÎÏÏÂ ÎÏÎÏÎÎ "
+"ÎÎ ÎÏÎÎÎÎÎÏÎ ÎÎ ÏÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎ ÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎ ÎÎÏÎÎÎ:"
+
+#: C/guitar-tuner.vala.page:76(p)
+msgid ""
+"The constructor of the <code>Main</code> class creates a new window by "
+"opening a GtkBuilder file (<file>src/guitar-tuner.ui</file>, defined a few "
+"lines above), connecting its signals and then displaying it in a window. "
+"This GtkBuilder file contains a description of a user interface and all of "
+"its elements. You can use Anjuta's editor to design GtkBuilder user "
+"interfaces."
+msgstr ""
+"Î ÎÎÏÎÏÎÎÏÎÏÏÎÏ ÏÎÏ ÎÎÎÏÎÏ <code>Main</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÎ ÏÎÏÎÎÏÏÎ "
+"ÎÎÎÎÎÎÎÏÎÏ ÎÎÎ ÎÏÏÎÎÎ GtkBuilder (<file>src/guitar-tuner.ui</file>, ÏÎÏ "
+"ÎÏÎÎÎÏÎÎ ÎÎÎÎÏ ÎÏÎÎÎÎÏ ÏÎÏÎÏÎÎÏ), ÏÏÎÎÎÎÎÏÎÏ ÏÎ ÏÎÎÎÏÎ ÏÎÏ ÎÎÎ ÎÏÎÎÏÎ "
+"ÎÎÏÎÎÎÎÎÎÏÎÏ ÏÎ ÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÏÏ ÏÎ ÎÏÏÎÎÎ GtkBuilder ÏÎÏÎÎÏÎÎ ÎÎÎ "
+"ÏÎÏÎÎÏÎÏÎ ÎÎÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÎÎÎ ÏÎÏÎ ÏÏÎ ÏÏÎÎÏÎÎÏÎ ÏÎÏ. ÎÏÎÏÎÎÏÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎÎ ÎÏÎÎÎÏÎÎÏÏÎ ÏÎÏ Anjuta ÎÎÎ ÏÏÎÎÎÎÏÎ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ "
+"GtkBuilder."
+
+#: C/guitar-tuner.vala.page:78(p)
+#| 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."
+msgid ""
+"Connecting signals is how you define what happens when you push a button, or "
+"when some other event happens. Here, the <code>on_destroy</code> function is "
+"called (and quits the app) when you close the window."
+msgstr ""
+"Î ÏÏÎÎÎÏÎ ÏÎÎÎÏÏÎ ÎÎÎÎÎ ÏÏÏ ÎÏÎÎÎÏÎ ÏÎ ÏÏÎÎÎÎÎÎÎ ÏÏÎÎ ÏÎÏÎÏÎ ÎÎÎ ÎÎÏÎÏÎ, Î "
+"ÏÏÎÎ ÏÏÎÎÎÎ ÎÎÏÎÎÎ ÎÎÎÎ ÏÏÎÎÎÎ. ÎÎÏ, ÎÎÎÎÎÏÎÎ Î ÏÏÎÎÏÏÎÏÎ "
+"<code>on_destroy</code> (ÎÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ) ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÏÎ "
+"ÏÎÏÎÎÏÏÎ."
+
+#: C/guitar-tuner.vala.page:82(p)
+msgid ""
+"The static <code>main</code> function is run by default when you start a "
+"Vala application. It calls a few functions which create the Main class, set "
+"up and then run the application. The <code>Gtk.main</code> function starts "
+"the GTK main loop, which runs the user interface and starts listening for "
+"events (like clicks and key presses)."
+msgstr ""
+"Î ÏÏÎÏÎÎÎ ÏÏÎÎÏÏÎÏÎ <code>main</code> ÏÏÎÏÎÎ ÎÏÏ ÏÏÎÎÏÎÎÎÎÎ ÏÏÎÎ ÎÎÎÎÎÎÏÎ "
+"ÎÎÎ ÎÏÎÏÎÎÎÎ Vala. ÎÎÎÎÎ ÎÎÎÎÏ ÏÏÎÎÏÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎÎ ÎÏÏÎÎ ÎÎÎÏÎ, "
+"ÏÏÎÎÎÎÎÏÎ ÎÎÎ ÎÏÎÎÏÎ ÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ. Î ÏÏÎÎÏÏÎÏÎ "
+"<code>Gtk.main</code> ÎÎÎÎÎÎ ÏÎÎ ÎÏÏÎÎ ÎÏÏÏÎ ÏÎÏ GTK, ÏÎÏ ÎÎÏÎÎÎÎ ÏÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎÏÏÎ ÎÎÎ ÎÎÎÎÎÎ ÏÎÎ ÎÏÎÎÏÎÏÎ ÎÎÎ ÏÏÎÎÎÎÏÎ (ÏÏÏÏ ÎÎÎÎ ÎÎÎ ÏÎÏÎÎÎÏÎ "
+"ÏÎÎÎÏÏÎÏ)."
+
+#: C/guitar-tuner.vala.page:86(p)
+msgid ""
+"This code is ready to be used, so you can compile it by clicking "
+"<guiseq><gui>Build</gui><gui>Build Project</gui></guiseq> (or press "
+"<keyseq><key>Shift</key><key>F7</key></keyseq>). When you do this, a dialog "
+"will appear. Change the <gui>Configuration</gui> to <gui>Default</gui> and "
+"then click <gui>Execute</gui> to configure the build directory. You only "
+"need to do this once, for the first build."
+msgstr ""
+"ÎÏÏÏÏ Î ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ. ÎÏÏÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÎ "
+"ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÎÎ ÎÎÎÎ <guiseq><gui>ÎÎÏÎÏÎÎÏÎ</gui><gui>ÎÎÏÎÏÎÎÏÎ "
+"ÎÏÎÎÏ</gui></guiseq> (Î ÏÎÏÏÎÏÎÏ "
+"<keyseq><key>Shift</key><key>F7</key></keyseq>). ÎÏÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÎÎ "
+"ÎÎÏÎÎÎÏÏÎÎ ÎÎÎÏ ÎÎÎÎÎÎÎÏ. ÎÎÎÎÎÏÎ ÏÎ <gui>ÏÏÎÎÎÏÎ</gui> ÏÎ "
+"<gui>ÏÏÎÎÏÎÎÎÎÎ</gui> ÎÎÎ ÎÏÎÎÏÎ ÎÎÎÎ <gui>ÎÎÏÎÎÎÏÎ</gui> ÎÎÎ ÏÏÎÎÎÏÎ ÏÎÏ "
+"ÎÎÏÎÎÏÎÎÏ ÎÎÏÎÏÎÎÏÎÏ. ÎÏÎÎÎÎÎÏÏÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ ÎÏÎÎ ÎÎÎ ÏÎÏÎ, ÎÎÎ ÏÎÎ "
+"ÏÏÏÏÎ ÎÎÏÎÏÎÎÏÎ."
+
+#: C/guitar-tuner.vala.page:90(title) C/guitar-tuner.py.page:84(title)
+#: C/guitar-tuner.cpp.page:83(title) C/guitar-tuner.c.page:88(title)
+msgid "Create the user interface"
+msgstr "ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ"
+
+#: C/guitar-tuner.vala.page:91(p)
+#| 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."
+msgid ""
+"A description of the user interface (UI) is contained in the GtkBuilder file "
+"<file>src/guitar_tuner.ui</file> defined at the top of the class. To edit "
+"the user interface, open <file>src/guitar_tuner.ui</file> by double-clicking "
+"on it in the <gui>Project</gui> or <gui>Files</gui> section. This will "
+"switch to the interface designer. The design window is in the center; "
+"<gui>Widgets</gui> and the widget properties are on the right, and the "
+"<gui>Palette</gui> of available widgets is on the left."
+msgstr ""
+"ÎÎÎ ÏÎÏÎÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ (UI) ÏÎÏÎÎÏÎÏÎÎ ÏÏÎ ÎÏÏÎÎÎ ÏÎÏ GtkBuilder "
+"<file>src/guitar_tuner.ui</file> ÏÎÏ ÎÏÎÏÏÎÎÎ ÏÏÎÎ ÎÎÏÏÏÎ ÏÎÏ ÎÎÎÏÎÏ. ÎÎÎ ÎÎ "
+"ÎÏÎÎÎÏÎÎÏÏÎÎÏÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ, ÎÎÎÎÎÏÎ ÏÎ "
+"<file>src/guitar_tuner.ui</file> ÎÎ ÎÎÏÎÏ ÎÎÎÎ ÏÎÎÏ ÏÎÏ ÏÏÎÎ ÎÎÏÏÎÏÎ "
+"<gui>ÎÏÎÎ</gui> Î <gui>ÎÏÏÎÎÎ</gui>. ÎÎ ÎÏÎÎÎÎÏÎ ÏÏÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ. ÎÎ "
+"ÏÎÏÎÎÏÏÎ ÏÏÎÎÎÎÏÎÏ ÎÎÎÎÎ ÏÏÎ ÎÎÎÏÏÎÂ ÏÎ <gui>ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ</gui> ÎÎÎ ÎÎ "
+"ÎÎÎÏÏÎÏÎÏ ÎÏÎÏÎÎÎÏ ÏÏÏÏÎÏÎÎÎÏ ÎÎÎÎÎ ÏÏÎ ÎÎÎÎÎ ÎÎÎ Î <gui>ÏÎÎÎÏÎ</gui> ÎÎ ÏÎ "
+"ÎÎÎÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÎÎÎÎ ÏÏÎ ÎÏÎÏÏÎÏÎ."
+
+#: C/guitar-tuner.vala.page:93(p)
+#| 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."
+msgid ""
+"The layout of every UI in GTK+ is organized using boxes and tables. Let's "
+"use a vertical GtkButtonBox here to assign six GtkButtons, one for each of "
+"the six guitar strings."
+msgstr ""
+"Î ÎÎÎÏÎÎÎ ÎÎÎÎ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÏÏÎ Gtk+ ÎÏÎÎÎÏÎÎÏÎÎ ÏÎ ÏÎÎÎÏÎÎ ÎÎÎ ÏÎÎÎÎÎÏ. "
+"ÎÏ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÏ ÎÎÎ ÎÎÎÎÏÎ GtkButtonBox ÎÎÎ ÎÎ ÎÏÎÎÏÏÎÏÎÎ ÎÎÎ "
+"GtkButtons, ÎÎÎ ÎÎÎ ÎÎÎÎ ÎÎÎ ÎÏÏ ÏÎÏ ÎÎÎ ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ."
+
+#: C/guitar-tuner.vala.page:99(p)
+msgid ""
+"In the <gui>Palette</gui> tab, from the <gui>Containers</gui> section, "
+"select a <gui>Button Box</gui> (GtkButtonBox) by clicking on the icon. Then "
+"click on the design window in the center to place it into the window. A "
+"dialog will display where you can set the <gui>Number of items</gui> to "
+"<input>6</input>. Then click <gui>Create</gui>."
+msgstr ""
+"ÎÏÎÎ ÎÎÏÏÎÎÎ <gui>ÏÎÎÎÏÎ</gui>, ÎÏÏ ÏÎÎ ÎÎÏÏÎÏÎ <gui>ÏÎÏÎÎÎÏÎÏ</gui>, "
+"ÎÏÎÎÎÎÏÎ ÎÎÎ <gui>ÏÎÎÎÏÎÎ ÎÎÏÎÏÎÎÏ</gui> (GtkButtonBox) ÎÎ ÎÎÎÎ ÏÏÎ "
+"ÎÎÎÎÎÎÎÎÎ. ÎÏÎÎÏÎ ÎÎÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÏÏÎÎÎÎÏÎÏ ÏÏÎ ÎÎÎÏÏÎ ÎÎÎ ÏÎÏÎÎÎÏÎÏÎ ÏÎÏ "
+"ÏÏÎ ÏÎÏÎÎÏÏÎ. ÎÎÎÏ ÎÎÎÎÎÎÎÏ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎÏ ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÏÎÏÎ ÏÎÎ "
+"<gui>ÎÏÎÎÎÏ ÏÏÎ ÏÏÎÎÏÎÎÏÎ</gui> ÏÎ <input>6</input>. ÎÏÎÎÏÎ ÎÎÎÎ ÏÏÎ "
+"<gui>ÎÎÎÎÎÏÏÎÎÎ</gui>."
+
+#: C/guitar-tuner.vala.page:100(p)
+msgid ""
+"You can also change the <gui>Number of elements</gui> and the "
+"<gui>Orientation</gui> in the <gui>General</gui> tab on the right."
+msgstr ""
+"ÎÏÎÏÎÎÏÎ ÎÏÎÏÎÏ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎÎ <gui>ÎÏÎÎÎÏ ÏÏÎ ÏÏÎÎÏÎÎÏÎ</gui> ÎÎÎ ÏÎÎ "
+"<gui>ÏÏÎÏÎÎÎÏÎÎÎÏÎÏ</gui> ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>ÎÎÎÎÎÎ</gui> ÏÏÎ ÎÎÎÎÎ."
+
+#: C/guitar-tuner.vala.page:104(p)
+msgid ""
+"Now, from the <gui>Control and Display</gui> section of the <gui>Palette</"
+"gui> choose a <gui>Button</gui> (GtkButton) by clicking on it. Place it into "
+"the first section of the GtkButtonBox by clicking in the first section."
+msgstr ""
+"ÎÏÏÎ, ÎÏÏ ÏÎÎ ÎÎÏÏÎÏÎ <gui>ÎÎÎÎÏÎÏ ÎÎÎ ÎÎÏÎÎÎÏÎ</gui> ÏÎÏ <gui>ÏÎÎÎÏÎÏ</gui> "
+"ÎÏÎÎÎÎÏÎ ÎÎÎ <gui>ÎÎÏÎÏÎ</gui> (GtkButton) ÎÎ ÎÎÎÎ ÏÎÎÏ ÏÎÏ. ÎÎÏÎÎÎÏÎÏÏÎ ÏÎ "
+"ÏÏÎÎ ÏÏÏÏÎ ÎÎÏÏÎÏÎ ÏÎÏ GtkButtonBox ÎÎ ÎÎÎÎ ÏÏÎÎ ÏÏÏÏÎ ÎÎÏÏÎÏÎ."
+
+#: C/guitar-tuner.vala.page:107(p)
+#| 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."
+msgid ""
+"While the button is still selected, scroll down in the <gui>General</gui> "
+"tab on the right to the <gui>Label</gui> property, and change it to <gui>E</"
+"gui>. This will be the low E guitar string."
+msgstr ""
+"ÎÏÎÎÏÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎÏÎÎ ÎÏÎÎÎÎÎÎÎÎ, ÎÏÎÎÏÏÎ ÎÎÏÏ ÏÏÎÎ ÎÎÏÏÎÎÎ "
+"<gui>ÎÎÎÎÎÎ</gui> ÏÏÎ ÎÎÎÎÎ ÏÎÏ ÎÎÎÏÏÎÏÎÏ <gui>ÎÏÎÎÎÏÎ</gui> ÎÎÎ ÎÎÎÎÎÏÎ ÏÎÎ "
+"ÏÎ <gui>E</gui>. ÎÏÏÎ ÎÎ ÎÎÎÎÎ Î ÏÎÎÎÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎÎÏÎÏ Î."
+
+#: C/guitar-tuner.vala.page:108(p)
+msgid ""
+"The <gui>General</gui> tab is located in the <gui>Widgets</gui> section on "
+"the right."
+msgstr ""
+"Î ÎÎÏÏÎÎÎ <gui>ÎÎÎÎÎÎ</gui> ÎÎÏÎÏÎÎÎÏÎÎ ÏÏÎÎ ÎÎÏÏÎÏÎ <gui>ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ</gui> ÏÏÎ ÎÎÎÎÎ."
+
+#: C/guitar-tuner.vala.page:113(p)
+#| 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>."
+msgid ""
+"Click on the <gui>Signals</gui> tab in the <gui>Widgets</gui> section on the "
+"right, 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>main_on_button_clicked</code> in the <gui>Handler</gui> column and "
+"press the <key>Enter</key>."
+msgstr ""
+"ÎÎÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>ÏÎÎÎÏÎ</gui> ÏÏÎÎ ÎÎÏÏÎÏÎ <gui>ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ</gui> ÏÏÎ ÎÎÎÎÎ ÎÎÎ ÎÏÎÎÏÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÎÏ "
+"ÎÎÏÎÏÎÎÏ. ÎÏÎÏÎÎÏÎ ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎÎ ÏÎÎÏÎÏÏÎ "
+"ÏÎÎÎÏÏÎ ÏÎÏ ÎÎ ÎÎÎÎÎÏÎÎ ÏÏÎÎ ÏÎÏÎÎÎÎ ÏÎ ÎÎÏÎÏÎ ÎÏÏ ÏÎÎ ÏÏÎÏÏÎ. ÎÎÎ ÎÎ ÏÎ "
+"ÎÎÎÎÏÎ ÎÏÏÏ, ÎÎÎÎ ÏÏÎ ÏÎÎÎ ÎÎÎ ÏÎÎÎÏÏÎÎÎÎÎÏÏÎ "
+"<code>main_on_button_clicked</code> ÏÏÎ ÏÏÎÎÎ <gui>ÏÎÎÏÎÏÏÎÏ</gui> ÎÎÎ "
+"ÏÎÏÎÏÏÎ <key>Enter</key>."
+
+#: C/guitar-tuner.vala.page:116(p) C/guitar-tuner.py.page:106(p)
+#: C/guitar-tuner.c.page:110(p)
+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>."
+
+#: C/guitar-tuner.vala.page:119(p) C/guitar-tuner.py.page:109(p)
+#: C/guitar-tuner.c.page:113(p)
+msgid ""
+"Save the UI design (by clicking <guiseq><gui>File</gui><gui>Save</gui></"
+"guiseq>) and keep it open."
+msgstr ""
+"ÎÏÎÎÎÎÎÏÏÏÎ ÏÎ ÏÏÎÎÎÎÏÎ UI (ÏÎÏÏÎÏÎÏ "
+"<guiseq><gui>ÎÏÏÎÎÎ</gui><gui>ÎÏÎÎÎÎÎÏÏÎ</gui></guiseq>) ÎÎÎ ÎÏÎÏÎÏÏÎ ÏÎ "
+"ÎÎÎÎÏÏÏ."
+
+#: C/guitar-tuner.vala.page:125(title) C/guitar-tuner.py.page:128(title)
+#: C/guitar-tuner.js.page:23(link) C/guitar-tuner.js.page:37(title)
+#: C/guitar-tuner.cpp.page:112(title) C/guitar-tuner.c.page:134(title)
+msgid "GStreamer pipelines"
+msgstr "ÎÏÎÎÎÏÏÎÎÏ GStreamer"
+
+#: C/guitar-tuner.vala.page:126(p)
+#| 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."
+msgid ""
+"This section will show you how to create the code to produce sounds. <link "
+"href=\"http://developer.gnome.org/platform-overview/stable/gstreamer";
+"\">GStreamer</link> 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 ""
+"ÎÏÏÎ Î ÎÎÏÏÎÏÎ ÎÎ ÎÎÎÎÎÎ ÏÏÏ ÎÎ ÏÎÏÎÎÎÎ Î ÎÏÎÎÎÎÏ ÎÏÎÏÏ. <link "
+"href=\"http://developer.gnome.org/platform-";
+"overview/stable/gstreamer\">GStreamer</link> ÎÎÎÎÎ Î ÏÎÎÎÎÏÏÏ ÏÎÎÏÎÎÏÏÎ ÏÎÏ "
+"GNOME - ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÏÎÎÎÎÎÎ, ÎÎÎÏÎÏÎ ÎÎÎ ÎÏÎÎÎÏÎÎÏÎÎ "
+"ÎÎÎÏÎÎ, ÎÏÎÏ, ÏÎÏÎ ÎÏÏÎÎÎÎÎÏÎÏ ÎÎÎ ÏÎ ÏÎÏÏÎÎÎÎ. ÎÎÏ, ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ "
+"ÎÎÎ ÎÎ ÏÎÏÎÎÎÏÎÎ ÏÏÎÎÏÏ ÎÎÎÏ ÏÏÏÎÏÏÎÏÎÏ."
+
+#: C/guitar-tuner.vala.page:127(p)
+#| 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."
+msgid ""
+"Conceptually, GStreamer works as follows: You create a <link href=\"http://";
+"gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html/section-intro-"
+"basics-bins.html\"><em>pipeline</em></link> 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 ÎÎÎÏÎÏÏÎÎÎ ÏÏ ÎÎÎÏ: ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÎÎ<link "
+"href=\"http://gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html";
+"/section-intro-basics-bins.html\"> <em>ÏÏÎÎÎÏÏÎ</em></link> ÏÎÏ ÏÎÏÎÎÏÎÎ "
+"ÎÎÎÏÎÏÎ ÏÏÎÎÏÎÎÎ ÎÏÎÎÎÏÎÎÏÎÎÏ ÏÎÏ ÏÎÎÎÎÎÎÏÎ ÎÏÏ ÏÎÎ <em>ÏÎÎÎ</em> ÏÏÎ "
+"<em>ÏÎÎÎÎÏÏÎÏÎ</em> (ÎÎÎÎÎ). Î ÏÎÎÎ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ, "
+"ÎÎÎÏÎÎ, Î ÎÎÏÏÎÎÎÏ, ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, ÎÎÎ Î ÎÎÎÎÎÏ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÏÎÏÎÎÏ "
+"ÏÏÏÏÎÏÎÎÏ Î ÎÎÏÏÎ ÎÏÎÏ."
+
+#: C/guitar-tuner.vala.page:128(p) C/guitar-tuner.py.page:131(p)
+#: C/guitar-tuner.js.page:40(p) C/guitar-tuner.cpp.page:116(p)
+#: C/guitar-tuner.c.page:137(p)
+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 ""
+"ÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎ ÎÎÎ ÏÏÎÎ ÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÏÎÏÏÎÏÎ ÎÎÎÏÎÏÎ ÏÎÎÏÏÎ ÎÎÎ "
+"ÎÎ ÎÎÏÎÏÏÎÏÎÎÏ ÎÎ ÏÎÎÏÎÏÏÎÏÎ ÎÏÎ, ÎÎÏÎÏÏÎÏÎÏ ÎÎÏÏÏÎ ÎÎÎ ÎÎÎÏÎ. ÎÎÎÎ ÏÏÎÎÏÎÎÎ "
+"ÏÎÏ ÏÏÎÎÎÏÏÎÏ ÎÏÎÎ ÎÎÎÏÏÎÏÎÏ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÏÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎ "
+"ÏÎ ÏÏÎÏÎÏÎÏÎÏÎ ÏÎÏÏ."
+
+#: C/guitar-tuner.vala.page:130(p) C/guitar-tuner.py.page:133(p)
+#: C/guitar-tuner.js.page:42(p) C/guitar-tuner.cpp.page:118(p)
+#: C/guitar-tuner.c.page:139(p)
+msgid "An example GStreamer pipeline."
+msgstr "ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÎÎÏÏÎÏ GStreamer."
+
+#: C/guitar-tuner.vala.page:135(title) C/guitar-tuner.py.page:138(title)
+#: C/guitar-tuner.c.page:144(title)
+msgid "Set up the pipeline"
+msgstr "ÎÏÎÎÎÏÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ"
+
+#: C/guitar-tuner.vala.page:136(p)
+#| 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>."
+msgid ""
+"In this 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>."
+
+#: C/guitar-tuner.vala.page:138(p)
+msgid ""
+"We need to add a line to initialize GStreamer; put the following code on the "
+"line above the <code>Gtk.init</code> call in the <code>main</code> function:"
+msgstr ""
+"ÎÏÎÎÎÎÎÏÎÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎÎ ÎÎÎ ÎÏÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎÏÎÎÎÏÎ ÏÎÏ GStreamer ÎÎÎÏÎ "
+"ÏÎÎ ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎ ÏÏÎÎ ÎÏÎÎÎÎ ÏÎÎÏ ÎÏÏ ÏÎÎ ÎÎÎÏÎ <code>Gtk.init</code> ÏÏÎ "
+"ÏÏÎÎÏÏÎÏÎ <code>main</code>:"
+
+#: C/guitar-tuner.vala.page:140(p)
+#| msgid ""
+#| "Then, copy the following function into the main class in "
+#| "<file>guitar_tuner.py</file> somewhere:"
+msgid ""
+"Then, copy the following function into <file>guitar_tuner.vala</file> inside "
+"our <code>Main</code> class:"
+msgstr ""
+"ÎÎÏÎ, ÎÎÏÎÎÏÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÏÏÎÎÏÏÎÏÎ ÏÏÎ <file>guitar_tuner.vala</file> "
+"ÎÎÏÎ ÏÏÎÎ ÎÎÎÏÎ ÎÎÏ <code>Main</code>:"
+
+#: C/guitar-tuner.vala.page:175(p)
+#| 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)."
+msgid ""
+"The first three lines create source and sink GStreamer elements (<link href="
+"\"http://valadoc.org/gstreamer-0.10/Gst.Element.html\";><code>Gst.Element</"
+"code></link>), and a <link href=\"http://valadoc.org/gstreamer-0.10/Gst.";
+"Pipeline.html\">pipeline element</link> (which will be used as a container "
+"for the other two elements). Those are class variables so they are defined "
+"outside the method. 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 ""
+"ÎÎ ÏÏÎÎÏ ÏÏÏÏÎÏ ÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ ÏÎÎÎ ÎÎÎ ÎÎÎÎÎ ÏÎÏ GStreamer "
+"(<link href=\"http://valadoc.org/gstreamer-0.10/Gst.Element.html\";><code>Gst."
+"Element</code></link>), ÎÎÎ ÎÎÎ <link "
+"href=\"http://valadoc.org/gstreamer-0.10/Gst.Pipeline.html\";>ÏÏÎÎÏÎÎÎ "
+"ÏÏÎÎÎÏÏÎÏ</link> (ÏÎ ÎÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ ÏÎÎ ÏÎÏÎÎÎÏÎÏ ÎÎÎ ÏÎ ÎÏÎ ÎÎÎÎ "
+"ÏÏÎÎÏÎÎÎ). ÎÏÏÎ ÎÎÎÎÎ ÎÎÏÎÎÎÎÏÎÏ ÎÎÎÏÎÏÎ, ÎÏÏÎ ÎÏÎÎÎÎÏÎÎ ÎÎÏ ÎÏÏ ÏÎ ÎÎÎÎÎÎ. "
+"ÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎÎ \"note\" ÏÏÎ ÏÏÎÎÎÏÏÎÂ ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÏÎÎÎ \"source\" ÎÎÎ "
+"ÏÏÎÎÎÎÎÏÎÎ ÏÏÎÎ ÏÎÎÎ <code>audiotestsrc</code>Â ÎÎÎ ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ "
+"\"output\" ÎÎÎ ÏÏÎÎÎÎÎÏÎÎ ÏÏÎÎ ÎÎÎÎÎ <code>autoaudiosink</code> (ÏÏÎÎÏÎÎÎÎÎÎÎÎ "
+"ÎÎÎÎÎÏ ÎÎÏÏÎÏ ÎÏÎÏ)."
+
+#: C/guitar-tuner.vala.page:178(p)
+#| 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."
+msgid ""
+"The call to <link href=\"http://valadoc.org/gobject-2.0/GLib.Object.set.html";
+"\"><code>source.set</code></link> sets the <code>freq</code> property of the "
+"source element to <code>frequency</code>, which is passed in 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 ""
+"Î ÎÎÎÏÎ ÏÏÎ <link href=\"http://valadoc.org/gobject-2.0/GLib.Object.set.html\"";
+"><code>source.set</code></link> ÎÏÎÎÎÎ ÏÎÎ ÎÎÎÏÏÎÏÎ <code>freq</code> ÏÎÏ "
+"ÏÏÎÎÏÎÎÎÏ ÏÎÎÎÏ ÏÎ <code>frequency</code>, Î ÎÏÎÎÎ ÎÏÎÎ ÏÎÏÎÏÏÎÎ ÏÏ ÏÏÎÏÎÎ "
+"ÏÏÎ ÏÏÎÎÏÏÎÏÎ <code>play_sound</code>. ÎÏÏÎ ÎÎÎÎÎ Î ÏÏÏÎÏÏÎÏÎ ÏÎÏ ÎÏÏÎÏ ÏÎ "
+"Hertz ÏÎÎÎÎÏ ÏÏÎÏÎÎÎÏ ÏÏÏÎÏÏÎÏÎÏ ÎÎ ÎÏÎÏÏÎÏÎ ÎÏÎÏÏÎÏÎ."
+
+#: C/guitar-tuner.vala.page:181(p)
+#| 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."
+msgid ""
+"<link href=\"http://valadoc.org/gstreamer-0.10/Gst.Bin.add.html";
+"\"><code>pipeline.add</code></link> puts the source and sink into the "
+"pipeline. The pipeline is a <link href=\"http://valadoc.org/gstreamer-0.10/";
+"Gst.Bin.html\"><code>Gst.Bin</code></link>, which is just an element that "
+"can contain multiple other GStreamer elements. In general, you can add as "
+"many elements as you like to the pipeline by adding more calls to "
+"<code>pipeline.add</code>."
+msgstr ""
+"ÎÎ <link href=\"http://valadoc.org/gstreamer-0.10/Gst.Bin.add.html\";><code>pip"
+"eline.add</code></link> ÎÎÎÎÎ ÏÎÎ ÏÎÎÎ ÎÎÎ ÏÎÎ ÎÎÎÎÎ ÏÏÎ ÏÏÎÎÎÏÏÎ. Î "
+"ÏÏÎÎÎÏÏÎ ÎÎÎÎÎ ÎÎÎ <link href=\"http://valadoc.org/gstreamer-0.10/Gst.Bin.htm";
+"l\"><code>Gst.Bin</code></link>,ÏÎÏ ÎÎÎÎÎ ÎÏÎÎ ÎÎÎ ÏÏÎÎÏÎÎÎ ÏÎÏ ÎÏÎÏÎÎ ÎÎ "
+"ÏÎÏÎÎÏÎÎ ÏÎÎÎÎÏÎÎ ÎÎÎÎ ÏÏÎÎÏÎÎÎ GStreamer. ÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ "
+"ÏÏÎ ÏÏÎÎÏÎÎÎ ÎÎÎÎÏÎ ÏÏÎ ÏÏÎÎÎÏÏÎ ÏÏÎÏÎÎÏÎÎÏÎÏ ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÎÎÏÎÎÏ ÏÏÎ "
+"<code>pipeline.add</code>."
+
+#: C/guitar-tuner.vala.page:184(p)
+msgid ""
+"Next, <link href=\"http://valadoc.org/gstreamer-0.10/Gst.Element.link.html";
+"\"><code>sink.link</code></link> is used to connect the elements together, "
+"so the output of source (a tone) goes into the input of sink (which is then "
+"output to the sound card). <link href=\"http://www.valadoc.org/gstreamer-";
+"0.10/Gst.Element.set_state.html\"><code>pipeline.set_state</code></link> is "
+"then used to start playback, by setting the <link href=\"http://www.valadoc.";
+"org/gstreamer-0.10/Gst.State.html\">state of the pipeline</link> to playing "
+"(<code>Gst.State.PLAYING</code>)."
+msgstr ""
+"ÎÎÏÏÏÎÎ, ÏÎ <link href=\"http://valadoc.org/gstreamer-0.10/Gst.Element.link.h";
+"tml\"><code>sink.link</code></link> ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÎ ÏÏÎÎÎÏÎ ÏÏÎ ÏÏÎÎÏÎÎÏÎ "
+"ÎÎÎÎ, ÎÏÏÎ ÏÏÏÎ Î ÎÎÎÎÎÏ ÏÎÏ ÏÎÎÎÏ (ÎÎÎÏ ÏÏÎÎÏ) ÎÎ ÏÎÎÎÎÎÎÎ ÏÏÎÎ ÎÎÏÎÎÎ ÏÎÏ "
+"ÎÎÏÎÎÏ (Î ÎÏÎÎÎ ÎÎÏÎ ÎÎÎÎÎ ÎÎÎÎÎÏ ÏÏÎÎ ÎÎÏÏÎ ÎÏÎÏ). ÎÎ <link href=\"http://w";
+"ww.valadoc.org/gstreamer-0.10/Gst.Element.set_state.html\"><code>pipeline.set"
+"_state</code></link> ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÏÎÎÏÎ ÎÎÎ ÏÎÎ ÎÎÎÎÎÎÏÎ ÏÎÏ "
+"ÎÎÎÏÎÏÎÎÏÎÎÏ, ÏÏÎÎÎÎÎÎÏÎÏ ÏÎÎ <link "
+"href=\"http://www.valadoc.org/gstreamer-0.10/Gst.State.html\";>ÎÎÏÎÏÏÎÏÎ ÏÎÏ "
+"ÏÏÎÎÎÏÏÎÏ</link> ÎÎ ÏÎÎÎÎÎ (<code>Gst.State.PLAYING</code>)."
+
+#: C/guitar-tuner.vala.page:187(p)
+#| 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>."
+msgid ""
+"We don't want to play an annoying tone forever, so the last thing "
+"<code>play_sound</code> does is to add a <link href=\"http://www.valadoc.org/";
+"glib-2.0/GLib.TimeoutSource.html\"><code>TimeoutSource</code></link>. This "
+"sets a timeout for stopping the sound; it waits for 200 milliseconds before "
+"calling a signal handler defined inline that stops and destroys the "
+"pipeline. It returns <code>false</code> to remove itself from the timeout, "
+"otherwise it would continue to be called every 200 ms."
+msgstr ""
+"ÎÎÎ ÎÎÎÎÏÎÎ ÎÎ ÏÎÎÎÎÏÎÎ ÎÎÎÎ ÎÎÎÏÎÎÏÎÎÏ ÎÏÎ ÎÎÎ ÏÎÎÏÎ, ÎÏÏÏÎ ÏÎ ÏÎÎÎÏÏÎÎÎ "
+"ÏÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎ Î <code>play_sound</code> ÎÎÎÎÎ ÎÎ ÏÏÎÏÎÎÏÎÎ ÎÎÎÎ <link hre"
+"f=\"http://www.valadoc.org/glib-2.0/GLib.TimeoutSource.html\";><code>TimeoutSou"
+"rce</code></link>. ÎÏÏÏ ÎÏÎÎÎÎ ÎÎÎ ÏÏÎÎÎÎÏ ÏÏÎÎ ÏÎÏ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÎÎ ÎÏÎÂ "
+"ÏÎÏÎÎÎÎÎÎ ÎÎÎ 200 ms ÏÏÎÎ ÎÎÎÎÏÎÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÎÏ ÏÎÏ ÎÏÎÏÏÎÎÎ ÏÏÎ "
+"ÎÏÎÎÎÎ ÏÎÏ ÏÏÎÎÎÏÎ ÎÎÎ ÎÎÏÎÏÏÏÎÏÎÎ ÏÎ ÏÏÎÎÎÏÏÎ. ÎÏÎÏÏÏÎÏÎÎ "
+"<code>false</code> ÎÎÎ ÎÎ ÎÏÎÎÏÎÏÎÎ ÏÎÎ ÎÎÎÎ ÎÏÏ ÏÎ ÏÏÎÎÎÎÏ ÏÏÎÎ, ÎÎÎÎÏÏ ÎÎ "
+"ÏÏÎÎÏÎÎÎ ÎÎ ÎÎÎÎÎÏÎÎ ÎÎÎÎ 200 ms."
+
+#: C/guitar-tuner.vala.page:197(title) C/guitar-tuner.c.page:119(title)
+#| msgid "Write the signal handler"
+msgid "Creating the signal handler"
+msgstr "ÎÎÎÎÎÏÏÎÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ"
+
+#: C/guitar-tuner.vala.page:198(p)
+#| 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."
+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. Actually "
+"we type <gui>main_on_button_clicked</gui> which tells the UI designer that "
+"this method is part of our <code>Main</code>. We need to add that function "
+"in the source file."
+msgstr ""
+"ÎÏÎÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ, ÎÎÎÎÏÎ ÏÎÎ ÏÎ ÎÎÏÎÏÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎÎ ÎÎÎÎ "
+"ÏÏÎÎÏÏÎÏÎ, <gui>on_button_clicked</gui>, ÏÏÎÎ ÏÎÏÎÎÎÏÎ. ÎÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎÏÎ, "
+"ÏÎÎÎÏÏÎÎÎÎÎÏÎÎ <gui>main_on_button_clicked</gui> ÏÎÏ ÎÎÎÎ ÏÏÎÎ ÏÏÎÎÎÎÏÏÎ UI "
+"ÏÏÎ ÎÏÏÎ Î ÎÎÎÎÎÎÏ ÎÎÎÎÎ ÏÎÎÎÎ ÏÎÏ <code>Main</code> ÎÎÏ. ÎÏÎÏÎÎ ÎÎ "
+"ÏÏÎÏÎÎÏÎÏÎÎ ÎÏÏÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ ÏÏÎ ÏÎÎÎÎÎ ÎÏÏÎÎÎ."
+
+#: C/guitar-tuner.vala.page:199(p)
+#| 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:"
+msgid ""
+"To do this, in the user interface file (guitar_tuner.ui) select one of the "
+"buttons by clicking on it, then open <file>guitar_tuner.vala</file> (by "
+"clicking on the tab in the center). Switch to the <gui>Signals</gui> tab on "
+"the right, which you used to set the signal name. Now take the row where you "
+"set the <gui>clicked</gui> signal and drag and drop it into to the source "
+"file at the beginning of the class. The following code will be added to your "
+"source file:"
+msgstr ""
+"ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÏÏÎ ÎÏÏÎÎÎ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ (guitar_tuner.ui), "
+"ÎÏÎÎÎÎÏÎ ÎÎÎ ÎÏÏ ÏÎ ÎÎÏÎÏÎÎ ÎÎ ÎÎÎÎ ÏÎÎÏ ÏÎÏ, ÎÏÎÎÏÎ ÎÎÎÎÎÏÎ "
+"<file>guitar_tuner.vala</file> (ÎÎ ÎÎÎÎ ÏÏÎÎ ÎÎÏÏÎÎÎ ÏÏÎ ÎÎÎÏÏÎ). ÎÎÎÎÎÎÎÎ "
+"ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>ÏÎÎÎÏÎ</gui> ÏÏÎ ÎÎÎÎÎ, ÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÏÎÎ ÎÏÎÏÎÏ "
+"ÏÎÏ ÎÎÏÎÎÏÎÏ ÎÏÏÎÎÎÏ. ÎÏÏÎ, ÏÎÏÏÎ ÏÎ ÎÏÎÎÎÎ ÏÏÎÏ ÎÏÎÏÎÏÎ ÏÎ ÏÎÎÎ "
+"<gui>ÏÎÏÎÎÎÎÎ</gui> ÎÎÎ ÏÏÏÏÎÎÎ ÎÎÎ ÎÏÏÎÎÏÎ ÏÎÏ ÏÏÎ ÏÎÎÎÎÎ ÎÏÏÎÎÎ ÏÏÎÎ ÎÏÏÎ "
+"ÏÎÏ ÎÎÎÏÎÏ. Î ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎÏ ÎÎ ÏÏÎÏÏÎÎÎÎ ÏÏÎ ÏÎÎÎÎÎ ÏÎÏ ÎÏÏÎÎÎ:"
+
+#: C/guitar-tuner.vala.page:206(p)
+msgid ""
+"You can also just type the code at the beginning of the class instead of "
+"using the drag and drop."
+msgstr ""
+"ÎÏÎÏÎÎÏÎ ÎÏÎÏÎÏ ÎÎ ÏÎÎÎÏÏÎÎÎÎÎÏÎÏÎ ÎÏÎÎ ÏÏÎ ÎÏÎÎÎÎ ÏÏÎÎ ÎÏÏÎ ÏÎÏ ÎÎÎÏÎÏ ÎÎÏÎ "
+"ÏÎÏ ÏÏÎÏÎÏ ÏÏÏÏÎÎÎÏÎÏ ÎÎÎ ÎÏÏÎÎÏÎÏ."
+
+#: C/guitar-tuner.vala.page:207(p)
+msgid ""
+"This signal handler has only one argument: the <link href=\"http://valadoc.";
+"org/gtk+-3.0/Gtk.Widget.html\"><code>Gtk.Widget</code></link> that called "
+"the function (in our case, always a <link href=\"http://valadoc.org/gtk+-3.0/";
+"Gtk.Button.html\"><code>Gtk.Button</code></link>)."
+msgstr ""
+"ÎÏÏÏÏ Î ÏÎÎÏÎÏÏÎÏ ÏÎÎÎÏÎÏ ÎÏÎÎ ÎÏÎÎ ÎÎÎ ÏÏÎÏÎÎ: ÏÎ <link href=\"http://valado";
+"c.org/gtk+-3.0/Gtk.Widget.html\"><code>Gtk.Widget</code></link> ÏÎÏ ÎÎÎÎÏÎ Î "
+"ÏÏÎÎÏÏÎÏÎ (ÏÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÏ, ÏÎÎÏÎÏÎ ÎÎÎ <link href=\"http://valadoc.org/gt";
+"k+-3.0/Gtk.Button.html\"><code>Gtk.Button</code></link>)."
+
+#: C/guitar-tuner.vala.page:213(title)
+#| msgid "Write the signal handler"
+msgid "Define the signal handler"
+msgstr "ÎÏÎÏÎÏÏ ÏÎÏ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ"
+
+#: C/guitar-tuner.vala.page:214(p)
+#| 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:"
+msgid ""
+"We want to play the correct sound when the user clicks a button. For this, "
+"we flesh out the signal handler which we defined above, "
+"<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 ""
+"ÎÎÎÎÏÎÎ ÎÎ ÏÎÎÎÎÏÎÎ ÏÎÎ ÏÏÏÏÏ ÎÏÎ ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎ ÎÎÎ ÎÎÏÎÏÎ. ÎÎÎ ÎÏÏÏ, "
+"ÎÏÎÏÎÎÎÏÎÏÎÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÎÏ ÏÎÏ ÎÏÎÏÎÎÎ ÏÎÏÎÏÎÎÏ, "
+"<code>on_button_clicked</code>. ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ ÎÏÎÏÎÎ ÏÏÎÎÎÏÎÎ ÎÎÎÎ ÎÎÏÎÏÎ "
+"ÏÎ ÎÎÎÏÎÏÎÏÎÎÏ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÎÏ, ÎÎÎÎ ÎÏÏÏ ÎÎ ÎÏÎÏÎÏÏÎ ÎÎ ÎÎÎÎÎÏÎÎ ÏÎ "
+"ÎÎÏÎÏÎÎÎÎÎ ÎÎÏÎÎÏÎÎÏÎÏ ÏÎÏ ÎÏÎÎÎÎ. ÎÎÏÎÎÎÏÎ, ÎÏÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ "
+"ÏÎÎ ÎÏÎÎÎÏÎ ÏÎÏ ÎÎÏÎÏÎÎÏ ÎÎÎ ÎÎ ÎÎÏÎÎÎÎÎÏÎÎ ÏÎÎÎ ÎÎÏÎÏÎ ÏÎÏÎÎÎÎÎ:"
+
+#: C/guitar-tuner.vala.page:242(p)
+#| 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>."
+msgid ""
+"The <code>Gtk.Button</code> that was clicked is passed as an argument "
+"(<code>sender</code>) to <code>on_button_clicked</code>. We can get the "
+"label of that button by using <code>get_child</code>, and then get the text "
+"from that label using <code>get_label</code>."
+msgstr ""
+"ÎÎ <code>Gtk.Button</code> ÏÎÏ ÏÎÏÎÎÎÎÎ ÏÎÏÎÎ ÏÏ ÏÏÎÏÎÎ "
+"(<code>sender</code>) ÏÏÎ <code>on_button_clicked</code>. ÎÏÎÏÎÏÎÎ ÎÎ "
+"ÏÎÏÎÏÎÎ ÏÎÎ ÎÏÎÎÎÏÎ ÎÏÏÎÏ ÏÎÏ ÎÎÏÎÏÎÎÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ "
+"<code>get_child</code> ÎÎÎ ÎÏÎÎÏÎ ÎÎ ÏÎÏÎÏÎÎ ÏÎ ÎÎÎÎÎÎÎ ÎÏÏ ÎÏÏÎÎ ÏÎÎ "
+"ÎÏÎÎÎÏÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ <code>get_label</code>."
+
+#: C/guitar-tuner.vala.page:243(p)
+#| 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!"
+msgid ""
+"The switch statement compares the label text to the notes that we can play, "
+"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> ÎÎ ÏÎÎ ÎÎÏÎÎÎÎÎÎ "
+"ÏÏÏÎÏÏÎÏÎ ÎÎÎ ÎÏÏÎÎ ÏÎÎ ÎÏÏÎ. ÎÏÏÏ ÏÎÎÎÎÎ ÏÎÎ ÏÏÎÎÂ Î ÏÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ "
+"ÎÎÎÎÎ ÎÏÎÎÎÎÏ!"
+
+#: C/guitar-tuner.vala.page:249(p) C/guitar-tuner.cpp.page:251(p)
+#: C/guitar-tuner.c.page:252(p)
+msgid ""
+"If you haven't already done so, choose the <file>Debug/src/guitar-tuner</"
+"file> application in the dialog that appears. Finally, hit <gui>Run</gui> "
+"and enjoy!"
+msgstr ""
+"ÎÎÎ ÎÎÎ ÏÎ ÎÏÎÏÎ ÎÎÎ ÎÎÎÎÎ, ÎÏÎÎÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ <file>Debug/src/guitar-"
+"tuner</file> ÏÏÎÎ ÎÎÎÎÎÎÎ ÏÎÏ ÎÎÏÎÎÎÎÎÏÎÎ. ÎÎÎÎÎÎ, ÏÎÏÎÏÏÎ "
+"<gui>ÏÏÎÎÎÎÎ</gui> ÎÎÎ ÎÏÎÎÎÏÏÏÎ!"
+
+#: C/guitar-tuner.vala.page:254(p)
+#| msgid ""
+#| "If you run into problems with the tutorial, compare your code with this "
+#| "<link href=\"guitar-tuner/guitar-tuner.py\">reference code</link>."
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"guitar-tuner/guitar-tuner.vala\">reference code</link>."
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÎÎÎÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏ "
+"ÏÎÎ <link href=\"guitar-tuner/guitar-tuner.vala\"> ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+
+#: C/guitar-tuner.vala.page:259(p)
+msgid ""
+"To find out more about the Vala programming language you might want to check "
+"out the <link href=\"http://live.gnome.org/Vala/Tutorial\";>Vala Tutorial</"
+"link> and the <link href=\"http://valadoc.org/\";>Vala API Documentation</"
+"link>"
+msgstr ""
+"ÎÎÎ ÎÎ ÎÏÎÎÏÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎ ÏÎ ÎÎÏÏÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Vala ÎÏÏÏ ÎÎÎÎÏÎÏÎ "
+"ÎÎ ÎÎÎÏÎÎÎÏÎ ÏÎ <link href=\"http://live.gnome.org/Vala/Tutorial\";>ÎÎÎÎÎÎ "
+"Vala</link> ÎÎÎ ÏÎ <link href=\"http://valadoc.org/\";>ÏÎÎÎÎÏÎÏÏÎ API "
+"Vala</link>"
+
+#: C/guitar-tuner.vala.page:268(p) C/guitar-tuner.py.page:237(p)
+#: C/guitar-tuner.cpp.page:272(p) C/guitar-tuner.c.page:265(p)
+msgid "Have the program automatically cycle through the notes."
+msgstr "ÎÎÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÏÎÏÎÎÎÎ ÎÏÏÏÎÎÏÎ ÎÎÏÎ ÎÏÏ ÏÎÏ ÎÏÏÎÏ."
+
+#: C/guitar-tuner.vala.page:271(p) C/guitar-tuner.py.page:240(p)
+#: C/guitar-tuner.cpp.page:275(p) C/guitar-tuner.c.page:268(p)
+msgid "Make the program play recordings of real guitar strings being plucked."
+msgstr ""
+"ÎÎÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÎ ÎÏÎÎÏÎÏÎÏÎÎÏ ÎÏÏ ÎÎÎÎÎÎÎÏ ÏÎÏÎÎÏ ÎÎÎÎÏÎÏ "
+"ÏÎÏ ÎÏÎÏÎ ÎÎÏÎÏÎÎÎ."
+
+#: C/guitar-tuner.vala.page:272(p) C/guitar-tuner.py.page:241(p)
+#: C/guitar-tuner.cpp.page:276(p) C/guitar-tuner.c.page:269(p)
+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 ""
+"ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÏÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎ ÏÏÎÎÎÏÏÎ "
+"GStreamer ÏÎÏ ÎÎ ÏÎÏ ÎÏÎÏÏÎÏÎÎ ÎÎ ÏÎÏÏÏÎÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÏÎ ÎÏÏÎÎÎ ÎÏÎÏ. "
+"ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ GStreamer <link "
+"href=\"http://gstreamer.freedesktop.org/documentation/plugins.html\";>decoder "
+"ÎÎÎ demuxer</link> ÎÎ ÎÎÏÎ ÏÎÎ ÏÏÏÎ ÏÎÏ ÎÏÏÎÎÎÏ ÏÏÎ ÎÏÎÎÏÎÏÎÎÎÎÏÎ ÎÏÏÎ â ÎÎÎ "
+"ÏÎÏÎÎÎÎÎÎÎ ÏÎ MP3 ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏÎÎÎ ÏÏÎÎÏÎÎÎ ÎÏÏ ÏÎ Ogg Vorbis."
+
+#: C/guitar-tuner.vala.page:273(p) C/guitar-tuner.py.page:242(p)
+#: C/guitar-tuner.cpp.page:277(p) C/guitar-tuner.c.page:270(p)
+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</link> ÏÎÏ ÎÎÎ ÎÎÎÏÏÏÎÏÎÎ ÏÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ, ÏÏÏÏ ÎÎÎ <link href="
+"\"http://gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html/";
+"section-intro-basics-pads.html\">pad</link>. ÎÏÏÏ ÎÏÎÎÏÎ ÏÏÎÏÎÎÎ ÎÎÎ ÏÎÎ "
+"ÎÎÏÎÎÎ <cmd>gst-inspect</cmd>."
+
+#: C/guitar-tuner.vala.page:276(p) C/guitar-tuner.py.page:245(p)
+#: C/guitar-tuner.cpp.page:280(p) C/guitar-tuner.c.page:273(p)
+msgid "Automatically analyze notes that the user plays."
+msgstr "ÎÏÏÏÎÎÏÎ ÎÎÎÎÏÏÎ ÎÏÏÏÎ ÏÎÏ ÏÎÎÎÎÎ Î ÏÏÎÏÏÎÏ."
+
+#: C/guitar-tuner.vala.page:277(p) C/guitar-tuner.py.page:246(p)
+#: C/guitar-tuner.cpp.page:281(p) C/guitar-tuner.c.page:274(p)
+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 (ÎÎÏÏÎÎÏ)</link>. ÎÏÏÏ ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ <link "
+"href=\"http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-";
+"good-plugins/html/gst-plugins-good-plugins-plugin-spectrum.html\">ÎÎÎÎÏÏÎÏ "
+"ÏÎÏÎÎÏÎÏ</link> ÎÎ ÏÎÏ ÎÎÎÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÏÎ ÏÎÎÎ ÎÏÏÎ ÏÎÎÎÎÎ;"
+
+#: C/guitar-tuner.py.page:9(desc) C/guitar-tuner.c.page:9(desc)
+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. ÎÎÎÎÎÎÎÎÏÎÎÏÎÏ ÏÏÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎ "
+"ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÏÎ."
+
+#: C/guitar-tuner.py.page:25(p) C/guitar-tuner.cpp.page:24(p)
+#: C/guitar-tuner.c.page:25(p)
+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 ""
+"ÎÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ, ÎÎ ÏÏÎÎÎÎÏÎÎ ÎÎÎ ÏÏÏÎÏÎÎÎÎ ÏÎÏ ÏÎÎÎÎÎ ÎÎÏÏÎÎÎÏÏ ÏÏÎÎÏÏ "
+"ÎÎÎ ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎÎÎÏÎ. ÎÎ ÎÎÎÎÏÎ ÎÎ:"
+
+#: C/guitar-tuner.py.page:27(p) C/guitar-tuner.cpp.page:26(p)
+#: C/guitar-tuner.c.page:27(p)
+msgid "Set up a basic project in Anjuta"
+msgstr "ÎÏÎÎÎÏÎ ÎÎÏÎÎÎÏ ÎÏÎÎÏ ÏÏÎ Anjuta"
+
+#: C/guitar-tuner.py.page:28(p) C/guitar-tuner.cpp.page:27(p)
+#: C/guitar-tuner.c.page:28(p)
+msgid "Create a simple GUI with Anjuta's UI designer"
+msgstr "ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÏÎÏ GUI ÎÎ ÏÎÎ ÏÏÎÎÎÎÏÏÎ UI ÏÎÏ Anjuta"
+
+#: C/guitar-tuner.py.page:29(p) C/guitar-tuner.cpp.page:28(p)
+#: C/guitar-tuner.c.page:29(p)
+msgid "Use GStreamer to play sounds"
+msgstr "ÎÏÎÏÎÎÎÏÎÎÎÎÏÎ ÏÎ GStreamer ÎÎÎ ÎÎ ÏÎÎÎÎÏÎ ÎÏÎÏÏ"
+
+#: C/guitar-tuner.py.page:34(p)
+msgid "Basic knowledge of the Python programming language"
+msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Python"
+
+#: C/guitar-tuner.py.page:48(p)
+#| 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."
+msgid ""
+"Choose <gui>PyGTK (automake)</gui> from the <gui>Python</gui> tab, click "
+"<gui>Continue</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>ÏÏÎÎÏÎÎÎ</gui> ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ "
+"ÎÏÏÎÎÎÎÏ ÎÎÎÎÏ ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÎÎÏÎÎÏÎÎÏ "
+"ÏÎ <file>guitar-tuner</file>."
+
+#: C/guitar-tuner.py.page:51(p)
+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>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ. ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ "
+"<gui>ÎÏÎÎ</gui> Î <gui>ÎÏÏÎÎÎ</gui> ÎÎÎÎÎÏÎ ÏÎ <file>src/guitar_tuner.py</"
+"file>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ ÏÎÏ ÎÏÎÎÎÎÏ:"
+
+#: C/guitar-tuner.py.page:60(title)
+msgid "Run the code for the first time"
+msgstr "ÎÎÏÎÎÎÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÎÎÎ ÏÏÏÏÎ ÏÎÏÎ"
+
+#: C/guitar-tuner.py.page:61(p)
+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 ""
+"Î ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÏÎÎÎÎÏ ÏÏÎ ÎÏÏÎÎÎ ÎÎÎÎÎ ÏÏÏÏÏÏÎ ÎÏÎÎÎÎ. ÎÎÏÏÏÎÎÎ ÎÎÎ (ÎÎÎÏ) "
+"ÏÎÏÎÎÏÏÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ ÏÎÏÎÎÏÎÏÎÏ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÎÎÎÎÎ. "
+"ÎÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏÏÎÏÎ ÏÎÎ ÎÎÏÏÂ ÏÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎ ÎÎÏÏÎ ÎÎ "
+"ÎÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎ ÎÎÏÎÎÎ:"
+
+#: C/guitar-tuner.py.page:65(p)
+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 ÎÎ ÏÎÏÏÏÏÎÎ ÏÎÏ "
+"ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏ ÏÏÏÏÎÎÎÏÎÏ ÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÏÎÏ ÏÏÎÎÎÎÎÎÏÎÎ."
+
+#: C/guitar-tuner.py.page:69(p)
+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>) ÎÎÎ ÏÎ ÏÎÎÎÏÎ ÏÏÎÎÎÎÎÏÎÎ."
+
+#: C/guitar-tuner.py.page:72(p)
+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> ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÏÎ ÏÎÏÎÎÏÏÎ (ÎÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ)."
+
+#: C/guitar-tuner.py.page:75(p)
+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. ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÏÎÎÏÎÏÎ (instance) ÏÎÏ ÎÏÏÎÎÏ ÎÎÎÏÎÏ "
+"main ÎÎÎ ÎÎÎÎÎÎÎÎ ÏÎÎ ÎÏÏÎÎ ÎÏÏÏÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ."
+
+#: C/guitar-tuner.py.page:80(p)
+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>ÎÎÏÎÎÎÏÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq>."
+
+#: C/guitar-tuner.py.page:85(p)
+#| 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."
+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 right, and the palette of "
+"available widgets is on the left."
+msgstr ""
+"ÎÎÎ ÏÎÏÎÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ (UI) ÏÎÏÎÎÏÎÏÎÎ ÏÏÎ ÎÏÏÎÎÎ GtkBuilder. ÎÎÎ "
+"ÎÎ ÎÏÎÎÎÏÎÎÏÏÎÎÏÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ, ÎÎÎÎÎÏÎ ÏÎ "
+"<file>src/guitar_tuner.ui</file>. ÎÎ ÎÏÎÎÎÎÏÎ ÏÏÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ. ÎÎ "
+"ÏÎÏÎÎÏÏÎ ÏÏÎÎÎÎÏÎÏ ÎÎÎÎÎ ÏÏÎ ÎÎÎÏÏÎÂ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÎÎ ÎÎ ÎÎÎÏÏÎÏÎÏ "
+"ÏÎÏÏ ÎÎÎÎÎ ÏÏÎ ÎÎÎÎÎ ÎÎÎ Î ÏÎÎÎÏÎ ÏÏÎ ÎÎÎÎÎÏÎÎÏÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ ÏÏÎ "
+"ÎÏÎÏÏÎÏÎ."
+
+#: C/guitar-tuner.py.page:87(p) C/guitar-tuner.cpp.page:86(p)
+#: C/guitar-tuner.c.page:91(p)
+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>, ÎÎÎ ÎÎÎ ÎÎÎÎ ÎÎÎ ÎÏÏ ÏÎÏ ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ."
+
+#: C/guitar-tuner.py.page:93(p) C/guitar-tuner.cpp.page:92(p)
+#: C/guitar-tuner.c.page:97(p)
+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>ÎÎÎÏÏÎÏÎÏ</gui> ÎÎÎÎÏÎÏÏÎ ÏÎÎ ÎÏÎÎÎÏ ÏÏÎ ÏÏÎÎÏÎÎÏÎ ÏÎ 6 (ÎÎÎ ÏÎÏ ÎÎÎ "
+"ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ) ÎÎÎ ÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏ ÏÎ ÎÎÎÎÏÎ."
+
+#: C/guitar-tuner.py.page:97(p) C/guitar-tuner.cpp.page:96(p)
+#: C/guitar-tuner.c.page:101(p)
+msgid ""
+"Now, choose a <gui>GtkButton</gui> from the palette and put it into the "
+"first part of the box."
+msgstr ""
+"ÎÏÏÎ, ÎÎÎÎÎÎÏÎ ÎÎÎ <gui>GtkButton</gui> ÎÏÏ ÏÎÎ ÏÎÎÎÏÎ ÎÎÎ ÎÎÎÏÎ ÏÎ ÏÏÎ "
+"ÏÏÏÏÎ ÎÎÏÎÏ ÏÎÏ ÎÎÏÏÎÎÏ."
+
+#: C/guitar-tuner.py.page:100(p) C/guitar-tuner.c.page:104(p)
+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>ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ</gui> ÏÎ <gui>E</gui>. ÎÏÏÎ ÎÎ ÎÎÎÎÎ Î ÏÎÎÎÎÎ "
+"ÏÎÏÎÎ Î."
+
+#: C/guitar-tuner.py.page:103(p) C/guitar-tuner.c.page:107(p)
+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>ÎÎÎÎÏÎ</gui> (ÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ</gui>) ÎÎÎ ÎÏÎÎÏÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÎÏ ÎÎÏÎÏÎÎÏ. "
+"ÎÏÎÏÎÎÏÎ ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ ÏÎÏ ÎÎ "
+"ÎÎÎÎÎÏÎÎ ÏÏÎÎ ÏÎÏÎÎÎÎ ÏÎ ÎÎÏÎÏÎ. ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÏÎÏÎÏÏÎ ÏÎÎÏ ÏÏÎÎ "
+"ÏÏÎÎÎ <gui>ÎÎÎÏÎÏÏÎÏ</gui> ÏÎÏ ÏÎÎÎÏÎÏ ÎÎÎ ÎÏÎÏÏÎ <code>on_button_clicked</"
+"code> ÎÎÎ ÏÎÏÎÏÏÎ <key>Return</key>."
+
+#: C/guitar-tuner.py.page:115(title)
+msgid "Write the signal handler"
+msgstr "ÎÏÎÏÏÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ"
+
+#: C/guitar-tuner.py.page:116(p) C/guitar-tuner.c.page:120(p)
+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>, ÏÏÎÎ ÏÎÏÎÎÎÏÎ. ÎÏÎÏÎÎ ÎÎ "
+"ÏÏÎÏÎÎÏÎÏÎÎ ÎÏÏÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ ÏÏÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ."
+
+#: C/guitar-tuner.py.page:117(p)
+#| 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:"
+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 class. The "
+"following code will be added to your source file:"
+msgstr ""
+"ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÎÎÎÎÎÏÎ ÏÎ <file>guitar_tuner.py</file>, ÎÏÎÎÏÎÏ "
+"ÎÎÎÎÏÏÏ ÎÎÎ ÏÎ ÎÏÏÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ. ÎÎÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ "
+"<gui>ÏÎÎÎÏÎ</gui> ÏÎÏ ÎÎÏÎÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÏÎÏÎÏÎ ÏÎ ÏÎÎÎÎ ÏÎÏ "
+"ÏÎÎÎÏÎÏ. ÎÏÏÎ ÏÎÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÏÎÏ ÎÏÎÏÎÏÎ ÏÎ ÏÎÎÎ <gui>clicked</gui> ÎÎÎ "
+"ÏÏÏÎÏÎ ÏÎÎ ÏÏÎÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ ÎÎÏÎ ÏÏÎÎ ÎÎÎÏÎ. Î ÎÎÏÎÎÏÎÎÏ ÎÏÎÎÎÎÏ ÎÎ "
+"ÏÏÎÏÏÎÎÎÎ ÏÏÎÎ ÏÎÎÎÎÎ ÏÎÏ ÎÏÏÎÎÎ:"
+
+#: C/guitar-tuner.py.page:123(p)
+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> ÏÎÏ ÎÎÎÎÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ."
+
+#: C/guitar-tuner.py.page:124(p) C/guitar-tuner.c.page:130(p)
+msgid ""
+"For now, we'll leave the signal handler empty while we work on writing the "
+"code to produce sounds."
+msgstr ""
+"ÎÎÎ ÏÎÎ ÏÏÎ, ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ ÎÎÎÎÎ ÎÎÎÏÏ ÎÎ ÎÏÏÎÎÎÎÎÏÎÎ ÎÎ "
+"ÏÎ ÎÏÎÏÎÎÎ ÏÎÏ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÏÎÏÎÎÎÎ ÏÎÏÏ ÎÏÎÏÏ."
+
+#: C/guitar-tuner.py.page:129(p) C/guitar-tuner.js.page:38(p)
+#: C/guitar-tuner.c.page:135(p)
+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 â ÎÏÎÏÎÎÏÎ "
+"ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÏÎ, ÎÏÎÎÏÎÏÎÏÎÏÎ, ÎÎÎ ÎÎ "
+"ÎÏÎÎÎÏÎÎÏÏÎÎÏÎ ÎÎÎÏÎÎ, ÎÏÎ, ÏÎÎÏ ÎÎÎÏÎÎ ÎÎÎ ÏÎ ÎÎÎÏÎ. ÎÎÏ, ÎÎ ÏÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÎÎ ÏÎÏÎÎÎÏÎÎ ÎÎÎÎÏ-ÏÏÏÎÏÏÎÏÎÏ ÏÏÎÏÎ."
+
+#: C/guitar-tuner.py.page:130(p) C/guitar-tuner.js.page:39(p)
+#: C/guitar-tuner.cpp.page:115(p) C/guitar-tuner.c.page:136(p)
+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> (ÎÎÎÎÎ). Î ÏÎÎÎ ÎÏÎÏÎÎ ÎÎ "
+"ÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ, ÎÎÎÏÎÎ, Î ÎÎÎ ÎÎÏÏÎÎÎÏ, ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, ÎÎÎ Î "
+"ÎÎÎÎÎÏ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ Î Î ÎÎÏÏÎ ÎÏÎÏ."
+
+#: C/guitar-tuner.py.page:139(p) C/guitar-tuner.cpp.page:129(p)
+#: C/guitar-tuner.c.page:145(p)
+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>."
+
+#: C/guitar-tuner.py.page:141(p)
+msgid ""
+"Change the import line in <file>guitar_tuner.py</file>, just at the "
+"beginning to :"
+msgstr ""
+"ÎÎÎÎÎÏÎ ÏÎ ÎÏÎÎÎÎ import ÏÏÎ ÎÏÏÎÎÎ <file>guitar_tuner.py</file>, ÎÏÎÎ ÏÏÎÎ "
+"ÎÏÏÎ ÏÎ :"
+
+#: C/guitar-tuner.py.page:143(p)
+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>:"
+
+#: C/guitar-tuner.py.page:147(p)
+#| msgid ""
+#| "Then, copy the following function into the main class in "
+#| "<file>guitar_tuner.py</file> somewhere:"
+msgid ""
+"Then, copy the following function into the class in <file>guitar_tuner.py</"
+"file> somewhere:"
+msgstr ""
+"ÎÎÏÎ, ÎÎÏÎÎÏÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÏÏÎÎÏÏÎÏÎ ÎÎÏÎÏ ÏÏÎÎ ÎÎÎÏÎ ÏÏÎ "
+"<file>guitar_tuner.py</file>:"
+
+#: C/guitar-tuner.py.page:163(p)
+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) (ÏÎ ÎÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÎÎÏÎÎÏ ÎÎÎ ÏÎ ÎÏÎ "
+"ÎÎÎÎ ÏÏÎÎÏÎÎÎ). ÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎÎ Ânote ÏÏÎ ÏÏÎÎÎÏÏΠÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÏÎÎÎ "
+"Âsource ÎÎÎ ÏÎ ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎ <code>audiotestsrc</code> ÎÎÎ "
+"ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ Âoutput ÎÎÎ ÏÎÎ ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÎÎÎ "
+"<code>autoaudiosink</code> (ÏÏÎÎÏÎÎÎÎÎÎÎÎ ÎÎÏÏÎ ÎÏÎÏ)."
+
+#: C/guitar-tuner.py.page:166(p)
+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 ÏÎÎÎÎÏ ÏÏÎÏÎÎÎÏ ÏÏÏÎÏÏÎÏÎÏ ÎÎ ÎÏÎÏÏÎÏÎ "
+"ÎÏÎÏÏÎÏÎ."
+
+#: C/guitar-tuner.py.page:169(p)
+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>, ÎÎÎÎÎÏÎÏ ÏÎÎ "
+"ÏÎÎÎ ÎÎÎ ÏÎÎ ÎÎÎÎÎ ÏÏÎ ÏÏÎÎÎÏÏÎ. Î ÏÏÎÎÎÏÏÎ ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎÎÏÎÎÎ ÏÎÏ GStreamer. ÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ ÏÏÎÎÏÎÎÎ ÎÎÎÎÏÎ "
+"ÏÏÎ ÏÏÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ ÏÏÎÎÏÏÎÎÎÎ ÏÎ ÎÎÎÎÎÎ <code>add</code>."
+
+#: C/guitar-tuner.py.page:172(p)
+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> ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎÎ Î "
+"ÎÎÎÏÎÏÎÎÏÎÎ, ÎÎÎÎÎÎÎÏÎÏ ÏÎÎ ÎÎÏÎÏÏÎÏÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ ÏÎ ÎÎÎÏÎÏÎÎÏÎÎ "
+"(<code>Gst.State.PLAYING</code>)."
+
+#: C/guitar-tuner.py.page:179(title) C/guitar-tuner.c.page:194(title)
+msgid "Stopping playback"
+msgstr "ÎÎÎÎÎÏÎ ÎÎÎÏÎÏÎÎÏÎÎÏ"
+
+#: C/guitar-tuner.py.page:180(p)
+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> ÏÎÎÎÎÏÏÎ ÏÎÏ "
+"ÎÎÏÏÎÏÎÎÎÏÏÎÏ ÏÏÎÎ ÎÎÎÎÏÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ <code>pipeline_stop</code>, ÎÎÎ ÎÎ "
+"ÏÏÎÎÏÎÏÎÎ ÎÎ ÏÎÎ ÎÎÎÎÎ ÎÎÏÏÎ Î <code>pipeline_stop</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ "
+"<code>False</code>."
+
+#: C/guitar-tuner.py.page:181(p)
+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>:"
+
+#: C/guitar-tuner.py.page:187(p)
+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) ÎÎÎÏÎÏ:"
+
+#: C/guitar-tuner.py.page:192(p)
+msgid ""
+"The call to <code>pipeline.set_state</code> pauses the playback of the "
+"pipeline."
+msgstr ""
+"ÎÏÎÎ ÎÎÎÎÎÏÎÎ Î <code>pipeline.set_state</code> Î ÎÎÎÏÎÏÎÎÏÎÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ "
+"ÏÏÎÎÎÏÎÎÎ."
+
+#: C/guitar-tuner.py.page:196(title) C/guitar-tuner.c.page:212(title)
+msgid "Define the tones"
+msgstr "ÎÏÎÏÏÎ ÏÎÏÏ ÏÏÎÎÏÏ"
+
+#: C/guitar-tuner.py.page:197(p)
+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 ÎÎÎÏÎÏ) ÎÎÏÎ ÏÎ ÎÎÎ ÎÎÎÎÎÏ "
+"(<em>dict</em> ÏÎÏ Python) ÏÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÏÎÎÎÎ ÎÎ ÏÎÏ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ "
+"ÎÎÏÎÎÏÎ ÏÏÎ ÏÎÏÎÏÎ:"
+
+#: C/guitar-tuner.py.page:210(p) C/guitar-tuner.c.page:222(p)
+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 ""
+"ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ ÏÎÏ ÎÏÎÏÎÎÎ ÏÏÎÎ, <code>on_button_clicked</"
+"code>. ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ ÎÎÏÎÎÎ ÏÏÎÎÎÏÎÎ ÏÎÎ ÏÎ ÎÎÏÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎÏÎÎÏ "
+"ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ, ÎÎÎÎ ÎÏÏÏ ÎÎ ÎÎÎÎÎÏÏÎ ÏÎ ÏÎÎÎÎÏ ÎÏÎÎÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎ. "
+"ÎÎÏÎ ÎÏÏÎÏ, ÎÏÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎÏ ÎÏÎÎÎÏÎÏ ÏÏÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎ "
+"ÎÎÏÎÎ ÏÎÎÎ ÏÎÏÎÎÎÎÎ:"
+
+#: C/guitar-tuner.py.page:218(p)
+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>."
+"ÎÎ ÎÎÏÎÏÎ ÏÎÏ ÏÎÏÎÎÎÎÎ ÏÎÏÎÎÎÎ ÏÎÎ ÏÎÏÎÎÎÏÏÎÏ (<code>button</code>) ÏÏÎ "
+"<code>on_button_clicked</code>. ÎÏÎÏÎÏÎÎ ÎÎ ÏÎÏÎÏÎÎ ÏÎÎ ÎÏÎÎÎÏÎ ÏÎÏ ÎÎÏÎÏÎÎÏ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ <code>button.get_child</code>, ÎÎÎ ÏÎ ÎÎÎÎÎÎÎ ÎÏÏ ÏÎÎ "
+"ÎÏÎÎÎÏÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ <code>label.get_label</code>."
+
+#: C/guitar-tuner.py.page:219(p)
+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> ÎÎ ÏÎÎ ÎÎÏÎÎÎÎÎÎ ÏÏÏÎÏÏÎÏÎ ÎÏÏ ÏÎÎ ÎÏÏÎ. "
+"ÎÏÏÏ ÏÎÎÎÎÎ ÏÎÎ ÏÏÎÎÂ Î ÏÏÎÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ!"
+
+#: C/guitar-tuner.py.page:224(p)
+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>ÎÎÏÎÎÎÏÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq>. ÎÏÎÎÎÏÏÏÎ "
+"ÏÎ!"
+
+#: C/guitar-tuner.py.page:229(p)
+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\">ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+
+#: C/guitar-tuner.js.page:15(desc)
+#| msgid ""
+#| "Use Gtk+ and GStreamer to build a simple guitar tuner application for "
+#| "GNOME. Shows off how to use the interface designer."
+msgid ""
+"Use Gtk+ and GStreamer to build a simple guitar tuner application for GNOME."
+msgstr ""
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ Gtk+ ÎÎÎ GStreamer ÎÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎ ÎÎÎ ÎÏÎÎ ÎÏÎÏÎÎÎÎ "
+"ÏÏÎÎÎÏÏÎ ÎÎÎÎÏÎÏ ÎÎÎ ÏÎ GNOME."
+
+#: C/guitar-tuner.js.page:21(p)
+msgid ""
+"In this tutorial we'll construct a small application, Guitar Tuner, using "
+"JavaScript and GTK+ and GStreamer. To do and run all the code examples "
+"yourself, you need an editor to write code in, terminal and GNOME 3. or "
+"higher installed into your computer."
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÎÎÎÎÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎÎ ÎÎÎ ÎÎÎÏÎ ÎÏÎÏÎÎÎÎ, Guitar Tuner, "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ JavaScript, GTK+ ÎÎÎ GStreamer. ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎ "
+"ÏÎÎ ÏÎ ÏÎÏÎÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ ÎÎ ÎÎÎÎÎ, ÏÏÎÎÎÎÏÏÎÏÏÎ ÎÎÎÎ ÎÏÎÎÎÏÎÎÏÏÎ ÎÎÎ ÏÎ "
+"ÎÏÎÏÎÎÎ ÏÎÏ ÎÏÎÎÎÎ, ÏÎÏÎÎÏÎÎÏ ÎÎÎ GNOME 3 Î ÎÎÏÎÎÎÎÎÏÏÎÏÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÏÏÎÎ "
+"ÏÏÎÎÎÎÎÏÏÎ ÏÎÏ."
+
+#: C/guitar-tuner.js.page:27(link) C/guitar-tuner.js.page:76(title)
+msgid "Buttons for the tunes"
+msgstr "ÎÎÏÎÏÎÎ ÎÎÎ ÏÎÏ ÎÎÎÏÎÎÎÏ"
+
+#: C/guitar-tuner.js.page:28(link) C/guitar-tuner.js.page:101(title)
+msgid "Making the sounds with GStreamer"
+msgstr "ÎÎÎÎÎÏÎÏ ÏÎÏÏ ÎÏÎÏÏ ÎÎ GStreamer"
+
+#: C/guitar-tuner.js.page:29(link) C/guitar-tuner.js.page:125(title)
+msgid "Connecting buttons to playSound"
+msgstr "ÎÏÎÎÎÎÎÏÎÏ ÎÎÏÎÏÎÎ ÏÏÎ playSound"
+
+#: C/guitar-tuner.js.page:30(link) C/guitar-tuner.js.page:148(title)
+msgid "The whole program"
+msgstr "ÎÎÎ ÏÎ ÏÏÏÎÏÎÎÎÎ"
+
+#: C/guitar-tuner.js.page:49(p)
+msgid ""
+"This line tells how to run the script. It needs to be the first line of the "
+"code and it needs to be executable. To get the execution rights go to "
+"terminal and run in right folder: chmod +x scriptname. Or you can use the "
+"graphical filemanager. Just go to the right folder where your code is, right "
+"click you code file, choose properties, click the permissions tab and check "
+"the box for allow executing file as a program"
+msgstr ""
+"ÎÏÏÎ Î ÎÏÎÎÎÎ ÎÎÎÎ ÏÏÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÎ ÏÎÎÎÏÎÎ. ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ Î ÏÏÏÏÎ "
+"ÎÏÎÎÎÎ ÏÎÏ ÎÏÎÎÎÎ ÎÎÎ ÎÎ ÎÎÎÎÎ ÎÎÏÎÎÎÏÎÎÎ. ÎÎÎ ÎÎÏÎ ÏÏÎ ÎÎÎÎÎÏÎÎÏÏÎ "
+"ÎÎÏÎÎÎÏÎÏ ÏÎÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÏÎÎÏÎÎÏ ÎÎÎ ÎÎÏÎÎÎÏÏÎ ÏÏÎÎ ÏÏÏÏÏ ÏÎÎÎÎÎ: chmod +x "
+"ÏÎÎÎÎ ÏÎÎÎÏÎÎÏ. Î ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎÎ ÎÎÎÏÎÎÏÎÏÏÎ ÎÏÏÎÎÎÏ "
+"ÎÏÎÏÎÎÏÎ. ÎÏÎÎ ÏÎÎÎÎÎÎÏÎ ÏÏÎÎ ÏÏÏÏÏ ÏÎÎÎÎÎ ÏÏÎÏ ÎÎÎÎÎ Î ÎÏÎÎÎÎÏ ÏÎÏ ÎÎÎÎ "
+"ÎÎÎÎ ÏÏÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÎÎÎ ÏÎÏ, ÎÏÎÎÎÎÏÎ ÎÎÎÏÏÎÏÎÏ, ÎÎÎÎ ÏÏÎÎ ÎÎÏÏÎÎÎ "
+"ÎÎÎÎÎÏÎÎÏÏÎ ÎÎÎ ÏÎÎÎÎÏÏÏÎ ÏÎ ÏÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÏÎÏÏÎÏÎÎ Î ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÏÎÎÎÏ "
+"ÏÏ ÏÏÏÎÏÎÎÎÎ"
+
+#: C/guitar-tuner.js.page:59(p)
+msgid ""
+"In order to have a working program we need to import a few GObject "
+"Introspection -libraries to our use. For working UI, we need Gtk and for "
+"Gstreamer to work we need Gst. These are imported in the beginning so we "
+"have them at use everywhere. Also in the beginning we import a construct "
+"Mainloop to handle the timeout to be used with the tuning sounds."
+msgstr ""
+"ÎÎÎ ÎÎ ÏÏÎÏÏÎÎ ÎÎÎ ÎÎÎÏÎÏÏÎÎÎÏ ÏÏÏÎÏÎÎÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎ ÎÎÎÎ "
+"GObject ÎÏÏÎÎÎÎÎÏÎÏ - ÎÎÎÎÎÎÎÎÎÎÏ ÎÎÎ ÏÎ ÏÏÎÏÎ ÎÎÏ. ÎÎÎ ÎÎÎÏÎÏÏÎÎÎÏ UI, "
+"ÏÏÎÎÎÎÎÏÎÎ Gtk ÎÎÎ ÎÎÎ Gstreamer ÏÏÎÎÎÎÎÏÎÎ Gst. ÎÏÏÎ ÎÎÏÎÎÎÎÏÎÎ ÏÏÎÎ ÎÏÏÎ "
+"ÎÎÎ ÎÎ ÏÎ ÎÏÎÏÎÎ ÎÎÎ ÏÏÎÏÎ ÏÎÎÏÎÏ. ÎÏÎÏÎÏ ÏÏÎÎ ÎÏÏÎ ÎÎÏÎÎÎÏÎÎ ÎÎÎÎ ÎÏÏÎÎ "
+"ÎÏÏÏÎ ÎÎÏÎÏÎÎÏÎÏ ÎÎÎ ÏÎÎÏÎÏÎÏ ÏÎÏ ÏÏÏÎÎÏ ÎÎÎÎÏ ÏÏÎ ÏÏÎÏÎ ÏÎÏ ÎÎ ÎÏÎÏÏ "
+"ÎÎÎÏÎÎÎÏ."
+
+#: C/guitar-tuner.js.page:73(p)
+msgid ""
+"Importing Gtk and Gst is not enough, we need to initialize them in order to "
+"get them working. When Gtk and Gst are up and running we need to create the "
+"window for the application. Later we are going to put all the buttons for "
+"making sounds inside this window. In order to get the window showing, we "
+"need to tell it to show and we need also to run the code with the Gtk.main()"
+msgstr ""
+"Î ÎÎÏÎÎÏÎÎ ÏÏÎ Gtk ÎÎÎ Gst ÎÎÎ ÎÎÎÎÎ ÎÏÎÎÏÎ, ÏÏÎÎÎÎÎÏÎÎ Î ÎÏÏÎÎÎÏÎÎÎÏÎ ÏÎÏÏ "
+"ÎÎÎ ÎÎ ÎÎÏÎÎÏÎÏÎ. ÎÏÎÎ ÏÎ Gtk ÎÎÎ Gst ÎÎÏÎÎÎÏÎÏÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÎ "
+"ÎÎÎÎÎÏÏÎÎÏÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ. ÎÏÎÏÏÎÏÎ ÏÏÏÎÎÎÏÎÎ ÎÎ ÎÎÎÎÏÎÎ "
+"ÏÎÎ ÏÎ ÎÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÎÏÎ ÎÏÎÏÏ ÎÎÏÎ ÏÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÏÏÎ. ÎÎÎ ÏÎÎ ÎÎÏÎÎÎÏÎ "
+"ÏÎÏ ÏÎÏÎÎÏÏÎÏ, ÏÏÎÎÎÎÏÎÎÏÏÎ ÎÎ ÏÎÏ ÏÎÏÎÎ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÎÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎ "
+"ÎÏÎÏÎÏ ÎÎ ÏÏÎÎÎÎ Î ÎÏÎÎÎÎÏ ÎÎ ÏÎ Gtk.main()"
+
+#: C/guitar-tuner.js.page:97(p)
+msgid ""
+"Because Gtk.Window can only contain a single widget, we need to create "
+"something under it to be able to add all the necessary buttons inside it. In "
+"this example we use Buttonbox. After creating the Buttonbox we create "
+"buttons with necessary labels. After we have the buttons we need to add them "
+"to the Buttonbox and the Buttonbox must be added to the Gtk.Window and "
+"everything in the Buttonbox must be shown."
+msgstr ""
+"ÎÏÎÎÎÎ ÏÎ Gtk.Window ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ, "
+"ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÏÎ ÎÏÏ ÎÎÏÏ ÏÎÏ ÎÎÎ ÎÎ ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÏÎÎ ÏÎÎ "
+"ÏÎ ÎÏÎÏÎÎÏÎÏÎ ÎÎÏÎÏÎÎ ÎÎÏÎ ÏÎÏ. ÎÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎÎÎÏÎÎ "
+"ÎÎÏÎÏÎÎÏ. ÎÎÏÎ ÏÎ ÎÎÎÎÎÏÏÎÎÎ ÏÎÏ ÏÎÎÎÏÎÎÏ ÎÎÏÎÏÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎÎ ÎÎÏÎÏÎÎ ÎÎ "
+"ÎÎÎÎÎÎÎÎÏ ÎÏÎÎÎÏÎÏ. ÎÏÎÏ ÎÏÎÏÎÎ ÏÎ ÎÎÏÎÏÎÎ ÏÏÎÏÎÎ ÎÎ ÏÎ ÏÏÎÏÎÎÏÎÏÎÎ ÏÏÎ "
+"ÏÎÎÎÏÎÎ ÎÎÏÎÏÎÎÏ ÎÎÎ ÏÎ ÏÎÎÎÏÎÎ ÎÎÏÎÏÎÎÏ ÏÏÎÏÎÎ ÎÎ ÏÏÎÏÏÎÎÎÎ ÏÏÎ Gtk.Window "
+"ÎÎÎ ÏÎÎ ÏÏÎ ÏÎÎÎÏÎÎ ÎÎÏÎÏÎÎÏ ÏÏÎÏÎÎ ÎÎ ÎÎÏÎÎÎÎÎÎÏÎÎ."
+
+#: C/guitar-tuner.js.page:98(p)
+msgid ""
+"After this stage you should have a window appearing to your screen showing 6 "
+"buttons. Right now the buttons don't do anything and we shall address that "
+"issue later. Before we can connect the button signals to something we need "
+"to code that something first."
+msgstr ""
+"ÎÎÏÎ ÎÏÏ ÎÏÏÏ ÏÎ ÏÏÎÎÎÎ ÏÏÎÏÎÎ ÎÎ ÎÏÎÏÎ ÎÎÎ ÎÎÏÎÎÎÎÏÎÎÎÎ ÏÎÏÎÎÏÏÎ ÏÏÎÎ ÎÎÏÎÎ "
+"ÏÎÏ ÏÎÏ ÎÎ ÎÎÎÏÎÎÎ 6 ÎÎÏÎÏÎÎ. ÎÏÏÎ ÏÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎÎÎÏÎ ÏÎÏÎÏÎ ÎÎÎ ÎÎ "
+"ÎÎÏÎÎÎÏÏÏÎÏÎÏÎÎ ÎÏÏÏ ÏÎ ÎÎÎÎ ÎÏÎÏÏÎÏÎ. ÎÏÎÎ ÎÎ ÎÏÎÏÎÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÎ "
+"ÏÎÎÎÏÎ ÏÎÏ ÎÎÏÎÏÎÎÏ ÎÎ ÎÎÏÎ ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÏÎÎÎÎÏÎÎÎÏÎÏÎÎ ÎÏÏÏ ÏÎ ÎÎÏÎ "
+"ÏÏÏÏÎ."
+
+#: C/guitar-tuner.js.page:121(p)
+msgid ""
+"The first thing we need to do is decide what tunes we want to make when we "
+"push a button. The frequencies list takes care of that. After that we get to "
+"actually making the sounds with the function playSound. For function "
+"playSound we give as an input a frequency (that we just defined in the "
+"frequencies variable). First thing we need to construct is a pipeline, a "
+"source and a sink. For the source we set the frequency. To the pipeline we "
+"add both the source and the sink and then we tell it to keep playing. As a "
+"last thing we use the const Mainloop to get the pipeline to pause after a "
+"500ms."
+msgstr ""
+"ÎÎ ÏÏÏÏÎ ÏÏÎÎÎÎ ÏÎÏ ÏÏÎÎÎÎÏÎÎÏÏÎ ÎÎÎÎÎ ÎÎ ÎÏÎÏÎÏÎÏÎÏÎÎ ÏÎ ÎÎÎÏÎÎÎÏ ÎÎÎÎÏÎÎ "
+"ÎÎ ÎÎÎÎÏÎÎ ÏÏÎÎ ÏÎÏÎÎÎ ÎÎÎ ÎÎÏÎÏÎ. Î ÎÎÏÏÎ ÏÏÏÎÎÏÎÏÏÎ ÏÎ ÏÏÎÎÏÎÎÎÎ. ÎÎÏÎ ÎÏÏ "
+"ÎÏÏÏ ÏÏÎÎÏÎÎÎÏÎÎ ÎÎ ÎÎÎÎÎ ÏÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎÏÎ ÏÎÏÏ ÎÏÎÏÏ ÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ "
+"playSound. ÎÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ playSound ÎÎÎÎÏÎÎ ÏÏ ÎÎÏÎÎÎ ÎÎÎ ÏÏÏÎÏÏÎÏÎ (ÏÎÏ "
+"ÎÏÎÎÏ ÎÏÎÏÎÎÎ ÏÏÎ ÎÎÏÎÎÎÎÏÎ ÏÏÏÎÎÏÎÏÏÎ). ÎÎ ÏÏÏÏÎ ÏÏÎÎÎÎ ÏÎÏ ÏÏÎÎÎÎÏÎÎÏÏÎ ÎÎ "
+"ÎÎÏÎÏÎÎÏÎÏÎÏÎÎ ÎÎÎÎÎ ÎÎÎ ÏÏÎÎÎÏÏÎ, ÎÎÎ ÏÎÎÎ ÎÎÎ ÎÎÎ ÎÎÎÎÎ. ÎÎÎ ÏÎÎ ÏÎÎÎ "
+"ÎÏÎÎÎÏÎÎ ÏÎ ÏÏÏÎÏÏÎÏÎ. ÎÏÎ ÏÏÎÎÎÏÏÎ ÏÏÎÏÎÎÏÎÏÎÎ ÎÎÎ ÏÎÎ ÏÎÎÎ ÎÎÎ ÏÎÎ ÎÎÎÎÎ "
+"ÎÎÎ ÎÏÎÎÏÎ ÏÎÏ ÎÎÎÎ ÎÎ ÏÏÎÎÏÎÏÎÎ ÎÎ ÏÎÎÎÎÎ. ÎÏ ÏÎÎÎÏÏÎÎÎ ÏÏÎÎÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÏÏÎÎÎÏÎ ÎÏÏÎÎÏ ÎÏÏÏÎÏ ÎÎÎ ÎÎ ÎÎÎÎÎ ÏÎÏÏÎ Î ÏÏÎÎÎÏÏÎ ÎÎÏÎ "
+"ÎÏÏ 500ms."
+
+#: C/guitar-tuner.js.page:122(p)
+msgid ""
+"Now we have the method of playing a tune when clicking a button. Next well "
+"make the conncetions between pushing a button and playing the correct sound "
+"from that button."
+msgstr ""
+"ÎÏÏÎ ÎÏÎÏÎÎ ÏÎ ÎÎÎÎÎÎ ÎÎÎÏÎÏÎÎÏÎÎÏ ÎÎÎÏ ÎÎÎÏÎÎÎÏ ÏÎÏÏÎÏÎÏ ÎÎÎ ÎÎÏÎÏÎ. ÎÎÏÎ "
+"ÎÎÎÎÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÎÏ ÎÎÏÎÎÏ ÏÎÏÎÎÎÏÎÏ ÎÎÏÏ ÎÎÏÎÏÎÎÏ ÎÎÎ ÎÎÎÏÎÏÎÎÏÎÎÏ ÏÎÏ "
+"ÏÏÏÏÎÏ ÎÏÎÏ ÎÏÏ ÎÏÏÏ ÏÎ ÎÎÏÎÏÎ."
+
+#: C/guitar-tuner.js.page:145(p)
+msgid ""
+"The method of connecting button clicks to playSound with the correct tune is "
+"by using the connect method of the button widget. So we yelp-check validate "
+"*pagechoose a button to be connected and type E.connect(\"clicked\", function"
+"(){playSound(frequencies.E);}); The connect tells that when pushing E, "
+"something should happen. The \"clicked\" tells the type of something "
+"happening to E and then in the function(){}; we the playSound happen with "
+"the correct tune that should be associated to the button."
+msgstr ""
+"Î ÎÎÎÎÎÎÏ ÏÏÎÎÎÏÎÏ ÎÎÏÎÏÎÎÏ ÏÎÏÎ ÏÎ playSound ÎÎ ÏÎ ÏÏÏÏÎ ÎÎÎÏÎÎÎ ÎÎÎÎÏÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ ÎÎÎÎÎÎ ÏÏÎÎÎÏÎÏ ÏÎÏ ÎÏÎÏÎÎÎÏ ÏÏÏÏÎÏÎÎÎÏ ÎÎÏÎÏÎÎÏ. ÎÏÏÎ "
+"yelp-check validate *pagechoose ÎÎÎ ÎÎÏÎÏÎ ÎÎ ÏÏÎÎÎÎÎÎ ÎÎÎ ÏÎÎÎÏÏÎÎÎÎÎÏÎÎ "
+"E.connect(\"clicked\", function(){playSound(frequencies.E);}); Î ÏÏÎÎÎÏÎ ÎÎÎÎ "
+"ÏÏÎ ÏÏÎÎ ÏÎÏÎÎÎ Î, ÎÎÏÎ ÎÎ ÏÏÎÎÎÎ. ÎÎ \"ÏÎÏÎÎÎÎÎ\" ÎÎÎÎ ÏÎÎ ÏÏÏÎ ÏÎÏ ÎÎÏÎ "
+"ÏÏÎÎÎÎÎÎÎ ÏÏÎ Î ÎÎÎ ÎÏÎÎÏÎ ÏÏÎ function(){}; ÏÏÎÎÎÎÎÎÎ ÏÎ playSound ÎÎ ÏÎ "
+"ÏÏÏÏÎ ÎÎÎÏÎÎÎ ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÏÏÏÎÏÎÏÏÎÎ ÎÎ ÏÎ ÎÎÏÎÏÎ."
+
+#: C/guitar-tuner.js.page:149(p)
+msgid ""
+"So this is what all the parts combined looks like. When running this code, "
+"you should be able to tune your guitar(if you have correctly calibrated "
+"speakers)."
+msgstr ""
+"ÎÏÏÎ ÎÏÏÏ ÎÎÎÎÎ ÏÏÏ ÎÎÎÏÎÎÏÎ ÏÎÎ ÏÎ ÎÎÏÎÎÎÎ ÏÎÎÎÎÏÎ. ÎÏÎÎ ÏÏÎÏÎÎ ÎÏÏÏÏ Î "
+"ÎÏÎÎÎÎÏ, ÎÎ ÎÏÎÏÎÏÏÎÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÏÎ ÏÎÎ ÎÎÎÎÏÎ ÏÎÏ (ÎÎÎ ÎÏÎÏÎ ÏÏÏÏÎ "
+"ÎÎÎÎÎÎÎÎÎÎÎÎÎ ÎÏÎÎÎ)."
+
+#: C/guitar-tuner.js.page:229(p)
+msgid ""
+"To run this application open Terminal, go to the folder where your "
+"application is stored and then run"
+msgstr ""
+"ÎÎÎ ÎÎ ÏÏÎÎÎÏÎ ÎÏÏÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÎÎÎÎÎÏÎ ÏÎÎ ÏÎÏÎÎÏÎÎÏ, ÏÎÎÎÎÎÎÏÎ ÏÏÎÎ "
+"ÏÎÎÎÎÎ ÏÏÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÎÏÎÎÎÎ Î ÎÏÎÏÎÎÎÎ ÏÎÏ ÎÎÎ ÎÎÏÎ ÏÏÎÎÏÎ ÏÎÎ"
+
+#: C/guitar-tuner.js.page:229(input)
+msgid "GJS_PATH=`pwd` gjs guitarTuner.js"
+msgstr "GJS_PATH=`pwd` gjs guitarTuner.js"
+
+#: C/guitar-tuner.js.page:234(p)
+#| msgid ""
+#| "If you run into problems with the tutorial, compare your code with this "
+#| "<link href=\"guitar-tuner/guitar-tuner.py\">reference code</link>."
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"guitar-tuner/guitar-tuner.js\">reference code</link>."
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÎÎÎÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏ "
+"ÏÎÎ <link href=\"guitar-tuner/guitar-tuner.js\">ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+
+#: C/guitar-tuner.cpp.page:8(desc)
+#| msgid ""
+#| "Use Gtk+ and GStreamer to build a simple guitar tuner application for "
+#| "GNOME. Shows off how to use the interface designer."
+msgid ""
+"Use GTKmm and GStreamermm to build a simple guitar tuner application for "
+"GNOME. Shows off how to use the interface designer."
+msgstr ""
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ Gtk+ ÎÎÎ GStreamer ÎÎÎ ÎÎ ÎÎÏÎÏÎÎÏÎÏÎÏÎ ÎÎÎ ÎÏÎÎ ÎÏÎÏÎÎÎÎ "
+"ÏÏÎÏÎÎÎÏÏÎ ÎÎÎÎÏÎÏ ÎÎÎ ÏÎ GNOME. ÎÎÎÎÎÎÎÎÏÎÎÏÎÏ ÏÎ ÏÏÎÏÎ ÏÎÏ ÏÏÎÎÎÎÏÏÎ "
+"ÎÎÎÏÎÏÏÎ."
+
+#: C/guitar-tuner.cpp.page:21(title) C/guitar-tuner.c.page:22(title)
+msgid "Guitar Tuner"
+msgstr "ÎÏÎÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ"
+
+#: C/guitar-tuner.cpp.page:33(p)
+#| msgid "Basic knowledge of the python programming language"
+msgid "Basic knowledge of the C++ programming language"
+msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ C++"
+
+#: C/guitar-tuner.cpp.page:47(p)
+#| 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."
+msgid ""
+"Choose <gui>GTKmm (Simple)</gui> from the <gui>C++</gui> tab, click "
+"<gui>Forward</gui>, and fill out your details on the next few pages. Use "
+"<file>guitar-tuner</file> as project name and directory."
+msgstr ""
+"ÎÏÎÎÎÎÏÎ <gui>GTKmm (ÎÏÎÏ)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>C++</gui>, ÎÎÎÎ "
+"<gui>ÎÏÏÎÏÏÎ</gui> ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ ÎÎÎÎÏ "
+"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÎÎÏÎÎÏÎÎÏ ÏÎ <file"
+">guitar-tuner</file>."
+
+#: C/guitar-tuner.cpp.page:50(p)
+msgid ""
+"Make sure that <gui>Configure external packages</gui> is selected. On the "
+"next page, select <em>gstreamermm-0.10</em> from the list to include the "
+"GStreamermm library in your project."
+msgstr ""
+"ÎÎÎÎÎÏÎÎÎÏÎ ÏÏÎ ÏÎ <gui>ÏÏÎÎÎÏÎ ÎÎÏÏÎÏÎÎÏÎ ÏÎÎÎÏÏÎ</gui> ÎÏÎÎÎÏÏÎÎÎ. ÎÏÎÎ "
+"ÎÏÏÎÎÎÎ ÏÎÎÎÎÎ, ÎÏÎÎÎÎÏÎ <em>gstreamer-0.10</em> ÎÏÏ ÏÎ ÎÎÏÏÎ ÎÎÎ "
+"ÏÏÎÏÎÏÎÎÎÏÎ ÏÎÏ ÎÎÎÎÎÎÎÎÎÎÏ GStreamermm ÏÏÎ ÎÏÎÎ ÏÎÏ."
+
+#: C/guitar-tuner.cpp.page:54(p)
+#| 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:"
+msgid ""
+"Click <gui>Finished</gui> and the project will be created for you. Open "
+"<file>src/main.cc</file> from the <gui>Project</gui> or <gui>File</gui> "
+"tabs. You should see some code which starts with the lines:"
+msgstr ""
+"ÎÎÏÎÏÏÎ <gui>ÏÎÎÎÏ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÏÎÏ. ÎÎÎÎÎÏÎ "
+"<file>src/main.cc</file> ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ <gui>ÎÏÎÎ</gui> Î "
+"<gui>ÎÏÏÎÎÎ</gui>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÎÏÎÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ ÏÎÏ "
+"ÎÏÎÎÎÎÏ:"
+
+#: C/guitar-tuner.cpp.page:68(p)
+msgid ""
+"The three <code>#include</code> lines at the top include the <code>config</"
+"code> (useful autoconf build defines), <code>gtkmm</code> (user interface) "
+"and <code>iostream</code> (STL). Functions from these libraries are used in "
+"the rest of the code."
+msgstr ""
+"ÎÎ ÏÏÎÎÏ ÎÏÎÎÎÎÏ <code>#include</code> ÏÏÎÎ ÎÎÏÏÏÎ ÏÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎÎ "
+"<code>config</code> (ÎÏÎÎÎÎ ÏÏÎÏÎÎÎ ÎÎÏÎÏÎÎÏÎ ÏÎÏ autoconf), "
+"<code>gtkmm</code> (ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ) ÎÎÎ <code>iostream</code> (STL). "
+"ÎÏÎÎÏÏÎÏÎÎÏ ÎÏÏ ÎÏÏÎÏ ÏÎÏ ÎÎÎÎÎÎÎÎÎÎÏ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÏÎÎ ÏÏÏÎÎÎÏÎ ÎÏÎÎÎÎ."
+
+#: C/guitar-tuner.cpp.page:71(p)
+msgid ""
+"The <code>main</code> function creates a new window by opening a GtkBuilder "
+"file (<file>src/guitar-tuner.ui</file>, defined a few lines above) and then "
+"displaying it in a window. The GtkBuilder file contains a description of a "
+"user interface and all of its elements. You can use Anjuta's editor to "
+"design GtkBuilder user interfaces."
+msgstr ""
+"Î ÏÏÎÎÏÏÎÏÎ <code>Main</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÎÎÏÎÏ ÎÎÎ "
+"ÎÏÏÎÎÎ GtkBuilder (<file>src/guitar-tuner.ui</file>, ÏÎÏ ÎÏÎÎÎÏÎÎ ÎÎÎÎÏ "
+"ÎÏÎÎÎÎÏ ÏÎÏÎÏÎÎÏ), ÎÎÎ ÎÏÎÎÏÎ ÎÎÏÎÎÎÎÎÎÏÎÏ ÏÎ ÏÎ ÏÎÏÎÎÏÏÎ. ÎÎ ÎÏÏÎÎÎ "
+"GtkBuilder ÏÎÏÎÎÏÎÎ ÎÎÎ ÏÎÏÎÎÏÎÏÎ ÎÎÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÎÎÎ ÏÎÏÎ ÏÏÎ "
+"ÏÏÎÎÏÎÎÏÎ ÏÎÏ. ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎÎ ÎÏÎÎÎÏÎÎÏÏÎ ÏÎÏ Anjuta ÎÎÎ "
+"ÏÏÎÎÎÎÏÎ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ GtkBuilder."
+
+#: C/guitar-tuner.cpp.page:74(p)
+msgid ""
+"Afterwards it calls a few functions which set up and then run the "
+"application. The <code>kit.run</code> function starts the GTKmm main loop, "
+"which runs the user interface and starts listening for events (like clicks "
+"and key presses)."
+msgstr ""
+"ÎÎÏÏÏÎÎ ÎÎÎÎÎ ÎÎÎÎÏ ÏÏÎÎÏÏÎÏÎÎÏ ÏÎÏ ÏÏÎÎÎÎÎÏÎ ÎÎÎ ÎÏÎÎÏÎ ÎÎÏÎÎÎÏÎ ÏÎÎ "
+"ÎÏÎÏÎÎÎÎ. Î ÏÏÎÎÏÏÎÏÎ <code>kit.run</code> ÎÎÎÎÎÎ ÏÎÎ ÎÏÏÎÎ ÎÏÏÏÎ ÏÎÏ GTK, "
+"ÏÎÏ ÎÎÏÎÎÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÎÎÎ ÎÎÎÎÎÎ ÏÎÎ ÎÏÎÎÏÎÏÎ ÎÎÎ ÏÏÎÎÎÎÏÎ (ÏÏÏÏ "
+"ÎÎÎÎ ÎÎÎ ÏÎÏÎÎÎÏÎ ÎÎÏÎÏÎÏÎ)."
+
+#: C/guitar-tuner.cpp.page:84(p) C/guitar-tuner.c.page:89(p)
+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>. ÎÎ ÎÏÎÎÎÎÏÎ ÏÏÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ. ÎÎ ÏÎÏÎÎÏÏÎ ÏÏÎÎÎÎÏÎÏ ÎÎÎÎÎ ÏÏÎ "
+"ÎÎÎÏÏÎÂ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÎÏ ÏÎÏÏ ÎÎÎÎÎ ÏÏÎ ÎÏÎÏÏÎÏÎ, Î "
+"ÏÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÏÎ ÎÎÎÎÎ."
+
+#: C/guitar-tuner.cpp.page:99(p)
+#| 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."
+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. "
+"Also change the <gui>Name</gui> property to <gui>button_E</gui>. This is the "
+"name we will refer to the widget later in code."
+msgstr ""
+"ÎÏÎÎÏÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎÏÎÎ ÎÏÎÎÎÎÎÎÎÎ, ÎÎÎÎÎÏÎ ÏÎÎ ÎÎÎÏÏÎÏÎ <gui>ÎÏÎÎÎÏÎ</gui> "
+"ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ</gui> ÏÎ <gui>E</gui>. ÎÏÏÎ ÎÎ ÎÎÎÎÎ Î "
+"ÏÎÎÎÎÎ ÏÎÏÎÎ Î. ÎÏÎÏÎÏ ÎÎÎÎÎÏÎ ÏÎÎ ÎÎÎÏÏÎÏÎ <gui>ÏÎÎÎÎ</gui> ÏÎ "
+"<gui>button_E</gui>. ÎÎ ÎÏÏÏ ÏÎ ÏÎÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÏÎÎ ÏÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ "
+"ÎÏÎÏÏÎÏÎ ÏÏÎÎ ÎÏÎÎÎÎ."
+
+#: C/guitar-tuner.cpp.page:103(p)
+#| 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>."
+msgid ""
+"Repeat the above steps for the other buttons, adding the next 5 strings with "
+"the labels <em>A</em>, <em>D</em>, <em>G</em>, <em>B</em>, and <em>e</em> "
+"and the names <em>button_A</em>, etc."
+msgstr ""
+"ÎÏÎÎÎÎÎÎÎÏÎ ÏÎ ÏÎÏÎÏÎÎÏ ÎÎÎÎÏÎ ÎÎÎ ÏÎ ÏÏÏÎÎÎÏÎ ÎÎÏÎÏÎÎ, ÏÏÎÏÎÎÏÏÎ ÏÎÏ "
+"ÎÏÏÎÎÎÎÏ 5 ÏÎÏÎÎÏ ÎÎ ÏÎÏ ÎÏÎÎÎÏÎÏ <em>A</em>, <em>D</em>, <em>G</em>, "
+"<em>B</em>, ÎÎÎ <em>e</em> ÎÎÎ ÏÎ ÎÎÏÎÎÏÎ <em>button_A</em>, ÎÎÏ."
+
+#: C/guitar-tuner.cpp.page:106(p)
+#| msgid ""
+#| "Save the UI design (by clicking <guiseq><gui>File</gui><gui>Save</gui></"
+#| "guiseq>) and keep it open."
+msgid ""
+"Save the UI design (by clicking <guiseq><gui>File</gui><gui>Save</gui></"
+"guiseq>) and close the file."
+msgstr ""
+"ÎÏÎÎÎÎÎÏÏÏÎ ÏÎ ÏÏÎÎÎÎÏÎ UI (ÏÎÏÏÎÏÎÏ "
+"<guiseq><gui>ÎÏÏÎÎÎ</gui><gui>ÎÏÎÎÎÎÎÏÏÎ</gui></guiseq>) ÎÎÎ ÎÎÎÎÏÏÎ ÏÎ "
+"ÎÏÏÎÎÎ."
+
+#: C/guitar-tuner.cpp.page:113(p)
+#| 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."
+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. GStreamermm is the C++ "
+"binding to GStreamer which we will use here."
+msgstr ""
+"ÎÎ Gtreamer ÎÎÎÎÎ Î ÏÎÎÎÎÏÏÏ ÏÎÎÏÎÎÏÏÎ ÏÎÏ GNOME â ÎÏÎÏÎÎÏÎ ÎÎ ÏÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÏÎÎ ÎÏÎÎÏÎÏÎÏÎ ÎÎÎ ÎÏÎÎÎÏÎÎÏÎÎ ÎÎÎÏÎÎ, ÎÏÎÏ, "
+"ÏÎÏÎ ÎÏÏÎÎÎÎÎÏÎÏ ÎÎÎ ÏÎ ÏÎÏÏÎÎÎÎ. ÎÎÏ, ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÎÎ "
+"ÏÎÏÎÎÎÏÎÎ ÎÎÎÎÏ ÏÏÏÎÏÏÎÏÎÏ ÏÏÎÏÎ. ÎÎ GStreamermm ÎÎÎÎÎ ÎÎÎÏ ÏÏÎÎÎÏÎÎÏ C++ "
+"ÏÏÎ GStreamer ÏÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÏ."
+
+#: C/guitar-tuner.cpp.page:123(title)
+msgid "Using GStreamermm"
+msgstr "ÎÏÎÏÎ GStreamermm"
+
+#: C/guitar-tuner.cpp.page:124(p)
+msgid ""
+"To use GStreamermm, it has to be initialised. We do that by adding the "
+"following line of code next to the <code>Gtk::Main kit(argc, argv);</code> "
+"line in <file>main.cc</file>:"
+msgstr ""
+"ÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎ GStreamermm, ÏÏÎÏÎÎ ÎÎ ÎÏÏÎÎÎÏÎÎÎÎÎÎ. ÎÎ ÎÎÎÎÏÎÎ "
+"ÎÏÏÏ ÏÏÎÏÎÎÏÎÎÏÎÏ ÏÎÎ ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎ ÏÎÏ ÎÏÎÎÎÎ ÎÎÏÎÎ ÏÏÎ ÎÏÎÎÎÎ "
+"<code>Gtk::Main kit(argc, argv);</code> ÏÏÎ <file>main.cc</file>:"
+
+#: C/guitar-tuner.cpp.page:126(code)
+#, no-wrap
+msgid "\tGst::init (argc, argv);"
+msgstr "\tGst::init (argc, argv);"
+
+#: C/guitar-tuner.cpp.page:127(p)
+msgid ""
+"While we are on it, also make sure that the <file>gstreamermm.h</file> is "
+"included in <file>main.cc</file> properly."
+msgstr ""
+"ÎÎÏ ÎÎÎÎÏÏÎ ÏÎ ÎÏÏÏ, ÎÎÎÎÎÏÎÎÎÏÎ ÎÏÎÏÎÏ ÏÏÎ ÏÎ <file>gstreamermm.h</file> "
+"ÏÎÏÎÎÏÎÏÎÎ ÎÎÏÎÎÎÎÎÎ ÏÏÎ <file>main.cc</file>."
+
+#: C/guitar-tuner.cpp.page:131(p)
+msgid ""
+"To simplify the handling of the pipeline we will define a helper class "
+"<code>Sound</code>. We do that in <file>main.cc</file> in order to keep this "
+"example simple, whereas you might usually want to use a separate file:"
+msgstr ""
+"ÎÎÎ ÎÏÎÎÏÎÎÎÏÎ ÏÎÏ ÏÎÎÏÎÏÎÎÏ ÏÎÏ ÏÏÎÎÎÏÏÎÏ ÎÎ ÎÏÎÏÎÏÎÎ ÎÎÎ ÎÎÎÎÎÏÎÎÎ ÎÎÎÏÎ "
+"<code>Sound</code>. ÎÎ ÎÎÎÎÏÎÎ ÏÏÎ <file>main.cc</file> ÎÎÎ ÎÎ ÎÏÎÏÎÏÎÏÎÎ "
+"ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÎÏÎÏ, ÎÎÏ ÎÏÏÏ ÏÏÎÎÎÏÏ ÎÎ ÎÎÎÎÏÎ ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎ "
+"ÎÎÏÏÏÎÏÏÏ ÎÏÏÎÎÎ:"
+
+#: C/guitar-tuner.cpp.page:178(p)
+msgid "The code has the following purpose:"
+msgstr "Î ÎÏÎÎÎÎÏ ÎÏÎÎ ÏÎÎ ÏÎÏÎÎÎÏÏ ÏÎÎÏÏ:"
+
+#: C/guitar-tuner.cpp.page:181(p)
+#| 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)."
+msgid ""
+"In the constructor, source and sink GStreamer elements (<code>Gst::Element</"
+"code>) are created, 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). After the "
+"elements have been added to the pipeline and linked together, the pipeline "
+"is ready to run."
+msgstr ""
+"ÎÏÎÎ ÎÎÏÎÏÎÎÏÎÏÏÎ, ÏÎ ÏÏÎÎÏÎÎÎ ÏÎÎÎÏ ÎÎÎ ÎÎÏÎÎÏ ÏÎÏ GStreamer "
+"(<code>Gst::Element</code>)ÎÎÎÎÎÏÏÎÎÏÎÏÎÎ ÎÎÎ ÎÎÎ ÏÏÎÎÏÎÎÎ ÏÏÎÎÎÏÏÎÏ (ÏÎ "
+"ÎÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ ÏÏ ÏÎÏÎÎÎÏÎÏ ÎÎÎ ÏÎ ÎÏÎ ÎÎÎÎ ÏÏÎÎÏÎÎÎ). ÎÎÎÎÏÎÎ ÏÎ "
+"ÏÎÎÎÎ \"note\" ÏÏÎ ÏÏÎÎÎÏÏÎÂ ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÏÎÎÎ \"source\" ÎÎÎ ÏÏÎÎÎÎÎÏÎÎ ÏÏÎÎ "
+"ÏÎÎÎ <code>audiotestsrc</code>Â ÎÎÎ ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ \"output\" ÎÎÎ ÏÎÎ "
+"ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÎÎÎ <code>autoaudiosink</code> (ÏÏÎÎÏÎÎÎÎÎÎÎÎ ÎÎÎÎÎÏ ÎÎÏÏÎÏ "
+"ÎÏÎÏ). ÎÏÎÏ ÏÎ ÏÏÎÎÏÎÎÎ ÏÏÎÏÏÎÎÎÏÎ ÏÏÎ ÏÏÎÎÎÏÏÎ ÎÎÎ ÏÏÎÎÎÎÎÏÎ ÎÎÎÎ, Î "
+"ÏÏÎÎÎÏÏÎ ÎÎÎÎÎ ÎÏÎÎÎÎ ÎÎ ÏÏÎÎÎÎ."
+
+#: C/guitar-tuner.cpp.page:184(p)
+msgid ""
+"<code>start_playing</code> sets the source element to play a particular "
+"frequency and then starts the pipeline so the sound actually starts playing. "
+"As we don't want to have the annoying sound for ages, a timeout is set up to "
+"stop the pipeline after 200 ms by calling <code>stop_playing</code>."
+msgstr ""
+"Î <code>start_playing</code> ÎÏÎÎÎÎ ÏÎ ÏÏÎÎÏÎÎÎ ÏÎÎÎÏ ÎÎ ÎÎÎÏÎÏÎÎÎÎ ÎÎÎ "
+"ÏÏÎÎÎÎÏÎÎÎÎÎ ÏÏÏÎÏÏÎÏÎ ÎÎÎ ÎÏÎÎÏÎ ÎÎÎÎÎÎ ÏÎ ÏÏÎÎÎÏÏÎ ÏÏÏÎ Î ÎÏÎÏ ÏÏÎÎ "
+"ÏÏÎÎÎÎÏÎÎÏÏÎÏÎ ÎÎ ÎÎÎÎÎÎÏÎÎ ÎÎÎÏÎÏÎÎÏÎÎ. ÎÎÎÏÏ ÎÎÎ ÎÎÎÎÏÎÎ ÎÎ ÎÏÎÏÎÎ ÏÎÎ "
+"ÎÎÎÏÎÎÏÎÎÏ ÎÏÎ ÎÎÎ ÏÎÎÏ, ÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎÎÎ ÏÏÏÎÎÏ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÎ "
+"ÏÏÎÎÎÏÏÎ ÎÎÏÎ ÎÏÏ 200 ms ÎÎÎÏÎÏÎÏ <code>stop_playing</code>."
 
+#: C/guitar-tuner.cpp.page:189(p)
 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!"
+"In <code>stop_playing</code> which is called when the timeout has elapsed, "
+"the pipeline is stopped and as such there isn't any sound output anymore. As "
+"GStreamermm uses reference counting through the <code>Glib::RefPtr</code> "
+"object, the memory is automatically freed once the <code>Sound</code> class "
+"is destroyed."
 msgstr ""
-"ÎÎ ÎÎÎÎÎÎÎ ÏÎÏ ÎÏÎÎÎÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎÎ ÎÎÎ ÏÎ ÎÎÎÎÎÏ ÎÎÎ "
-"ÎÎÎÎÎÏÎÎ Î <code>play_sound</code> ÎÎ ÏÎÎ ÎÎÏÎÎÎÎÎÎ ÏÏÏÎÏÏÎÏÎ ÎÏÏ ÏÎÎ ÎÏÏÎ. "
-"ÎÏÏÏ ÏÎÎÎÎÎ ÏÎÎ ÏÏÎÎÂ Î ÏÏÎÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ!"
+"ÎÏÎÎ <code>stop_playing</code> ÏÎÏ ÎÎÎÎÎÏÎÎ ÏÏÎÎ Î ÎÎÎÎ ÏÏÏÎÎÏ ÏÎÏÎÏÎÎ, Î "
+"ÏÏÎÎÎÏÏÎ ÏÏÎÎÎÏÎ ÎÎÎ ÎÏÏÎ ÎÎÎ ÏÏÎÏÏÎÎ ÎÎÎÎÎÎÏ ÎÏÎÏ ÎÎÏÎÎÏ ÏÎÎ. ÎÎÎÏÏ ÏÎ "
+"GStreamermm ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÎÏÏÎÏÎ ÎÎÎÏÎÏÎÏ ÎÎÏÎ ÎÏÏ ÏÎ ÎÎÏÎÎÎÎÎÎÎÎ "
+"<code>Glib::RefPtr</code>, Î ÎÎÎÎÎ ÎÏÏÏÎÎÏÎ ÎÎÎÏÎÎÏÏÎÎÏÎÎ ÎÏÎÎÏ Î ÎÎÎÏÎ "
+"<code>Sound</code> ÎÎÏÎÏÏÏÎÏÎÎ."
 
+#: C/guitar-tuner.cpp.page:197(title)
+msgid "Connecting the signals"
+msgstr "ÎÏÎÎÎÏÎ ÏÎÎÎÏÏÎ"
+
+#: C/guitar-tuner.cpp.page:198(p)
 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!"
+"We want to play the correct sound when the user clicks a button. That means "
+"that we have to connect to the signal that is fired when the user clicks the "
+"button. We also want to provide information to the called function which "
+"tone to play. GTKmm makes that quite easy as we can easily bind information "
+"with the <em>sigc</em> library."
 msgstr ""
-"ÎÎ ÏÏÏÎÏÎÎÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÏÎÎÎÎ ÏÏÏÎ. ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ "
-"ÏÎÏÎÏÏÎ <guiseq><gui>ÎÎÏÎÎÎÏÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq>. ÎÏÎÎÎÏÏÏÎ "
-"ÏÎ!"
+"ÎÎÎÎÏÎÎ ÎÎ ÏÎÎÎÎÏÎÎ ÏÎÎ ÏÏÏÏÏ ÎÏÎ, ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎ ÎÎÎ ÎÎÏÎÏÎ. ÎÏÏÏ "
+"ÏÎÎÎÎÎÎÎ ÏÏÎ ÏÏÎÏÎÎ ÎÎ ÏÏÎÎÎÎÎÏÎÎ ÏÏÎ ÏÎÎÎ ÏÎÏ ÎÎÎÎÎÎ ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎ ÏÎ "
+"ÎÎÏÎÏÎ. ÎÎÎÎÏÎÎ ÎÏÎÏÎÏ ÎÎ ÎÏÏÎÏÎÎ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÎ ÎÎÎÎÏÎÎÎÎ ÏÏÎÎÏÏÎÏÎ ÏÎÎÎ "
+"ÏÏÎÎ ÎÎ ÏÎÎÎÎÎ. ÎÎ GTKmm ÏÎ ÎÎÎÎÎ ÎÏÎÎÏÎ ÎÏÎÏ ÎÎÎÏÏ ÎÏÎÏÎÏÎÎ ÎÏÎÎÎÎ ÎÎ "
+"ÏÏÎÎÎÏÎÏÎÎ ÏÎÎÏÎÏÎÏÎÎÏ ÎÎ ÏÎ ÎÎÎÎÎÎÎÎÎÎ <em>sigc</em>."
 
+#: C/guitar-tuner.cpp.page:203(p)
+msgid ""
+"The function that is called when the user clicks a button can be pretty "
+"simple, as all the interesting stuff is done in the helper class now:"
+msgstr ""
+"Î ÏÏÎÎÏÏÎÏÎ ÏÎÏ ÎÎÎÎÎÏÎÎ ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎ ÎÎÎ ÎÎÏÎÏÎ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ "
+"ÎÏÎÎÏÎ ÎÏÎÎ, ÎÎÎÏÏ ÏÎÎ ÏÎ ÎÎÎÎÎÏÎÏÎÎ ÏÎÎÎÏ ÎÎÎÎÏÎÎ ÏÏÏÎ ÏÏÎ ÎÎÎÎÎÏÎÎÎ ÎÎÎÏÎ:"
+
+#: C/guitar-tuner.cpp.page:212(p)
+msgid ""
+"It only calls the helper class we defined before to play the correct "
+"frequencies. With some more clever code we would also have been able to "
+"directly connect to the class without using the function but we will leave "
+"that to use as an exercise."
+msgstr ""
+"ÎÎÎÎÎ ÎÏÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÎÎÎÏÎ ÏÎÏ ÎÏÎÏÎÎÎ ÏÏÎÎ ÎÎ ÏÎÎÎÎÎ ÏÎÏ ÏÏÏÏÎÏ "
+"ÏÏÏÎÏÏÎÏÎÏ. ÎÎ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎÎ ÎÏÎÎÎÎ ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÏÎÏÎÏ ÎÎ ÎÏÎÏÎÏÎÏÎÎ ÏÎÎ "
+"ÎÎÎÏÎ ÏÏÎÎÎÏÎ ÏÏÎÎ ÎÎÎÏÎ ÏÏÏÎÏ ÏÏÎÏÎ ÏÎÏ ÏÏÎÎÏÏÎÏÎÏ, ÎÎÎÎ ÎÎ ÏÎ ÎÏÎÏÎÏÎÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ ÏÏ ÎÏÎÎÏÎ."
+
+#: C/guitar-tuner.cpp.page:216(p)
+msgid ""
+"The code to set up the signals should be added to the <code>main()</code> "
+"function just after the <code>builder-&gt;get_widget(\"main_window\", "
+"main_win);</code> line:"
+msgstr ""
+"Î ÎÏÎÎÎÎÏ ÎÎÎ ÏÏÎÎÎÏÎ ÏÏÎ ÏÎÎÎÏÏÎ ÏÏÎÏÎÎ ÎÎ ÏÏÎÏÏÎÎÎÎ ÏÏÎ ÏÏÎÎÏÏÎÏÎ "
+"<code>main()</code> ÎÎÎÏÏÏ ÎÎÏÎ ÏÎ ÎÏÎÎÎÎ "
+"<code>builder-&gt;get_widget(\"main_window\", main_win);</code>:"
+
+#: C/guitar-tuner.cpp.page:228(p)
+msgid ""
+"At first we create an instance of our helper class that we want to use now "
+"and declare a variable for the button we want to connect to."
+msgstr ""
+"ÎÏÏÏÎ ÎÎÎÎÎÏÏÎÎÏÎÎ ÎÎÎ ÏÏÎÎÎÎÏÏÏÏÎ ÏÎÏ ÎÎÎÎÎÏÎÎÎÏ ÎÎÏ ÎÎÎÏÎÏ ÏÎÏ ÎÎÎÎÏÎÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÏÏÎ ÎÎÎ ÎÎÎÏÎÎÏÎÎ ÎÎÎ ÎÎÏÎÎÎÎÏÎ ÎÎÎ ÏÎ ÎÎÏÎÏÎ ÏÏÎ ÎÏÎÎÎ "
+"ÎÎÎÎÏÎÎ ÎÎ ÏÏÎÎÎÎÎÏÎÎ."
+
+#: C/guitar-tuner.cpp.page:232(p)
+msgid ""
+"Next, we receive the button object from the user interface that was created "
+"out of the user interface file. Remember that <em>button_E</em> is the name "
+"we gave to the first button."
+msgstr ""
+"ÎÎÏÏÏÎÎ, ÎÎÏÏÎÎÏÏÎ ÏÎ ÎÎÏÎÎÎÎÎÎÎÎ ÎÎÏÎÏÎÎÏ ÎÏÏ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÏÎÏ "
+"ÎÎÎÎÎÏÏÎÎÎÎÎÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ. ÎÎ ÎÏÎÎÏÏÎ ÏÏÎ "
+"<em>button_E</em> ÎÎÎÎÎ ÏÎ ÏÎÎÎÎ ÏÎÏ ÎÏÏÎÎÎ ÏÏÎ ÏÏÏÏÎ ÎÎÏÎÏÎ."
+
+#: C/guitar-tuner.cpp.page:236(p)
+msgid ""
+"Finally we connect the <em>clicked</em> signal. This isn't fully "
+"straightforward because this is done in a fully type-safe way and we "
+"actually want to pass the frequency and our helper class to the signal "
+"handler. <code>sigc::ptr_fun(&amp;on_button_clicked)</code> creates a "
+"<em>slot</em> for the <code>on_button_clicked</code> method we defined "
+"above. With <code>sigc::bind</code> we are able to pass additional arguments "
+"to the slot and in this case we pass the frequency (as double) and our "
+"helper class."
+msgstr ""
+"ÎÎÎÎÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎ <em>ÏÎÏÎÎÎÎÎ</em>. ÎÏÏÏ ÎÎÎ ÎÎÎÎÎ ÏÎÎÏÏÏ ÎÎÏÎÎÎÎÏÏ "
+"ÎÏÎÎÎÎ ÎÏÏÏ ÎÎÎÎÏÎÎ ÎÎ ÎÎÎÎ ÏÎÎÏÎ ÏÏÏÏÎ ÎÏÏÎÎÎÏÏ ÏÏÏÎÏ ÎÎÎ ÏÏÎÎ "
+"ÏÏÎÎÎÎÏÎÎÏÏÎÏÎ ÎÎÎÎÏÎÎ ÎÎ ÏÎÏÎÏÎÏÎÎ ÏÎ ÏÏÏÎÏÏÎÏÎ ÎÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÎÎÏ ÎÎÎÏÎ "
+"ÏÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÎÏ. Î <code>sigc::ptr_fun(&amp;on_button_clicked)</code> "
+"ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ <em>ÏÏÎÎÎÏÎ</em> ÎÎÎ ÏÎ ÎÎÎÎÎÎ <code>on_button_clicked</code> "
+"ÏÎÏ ÎÏÎÏÎÎÎ ÏÎÏÎÏÎÎÏ. ÎÎ ÏÎÎ <code>sigc::bind</code> ÎÏÎÏÎÏÎÎ ÎÎ ÏÎÏÎÏÎÏÎÎ "
+"ÏÏÏÏÎÎÏÎ ÎÏÎÏÎÎÏÎ ÏÏÎÎ ÏÏÎÎÎÏÎ ÎÎÎ ÏÎ ÎÏÏÎÎ ÏÎÎ ÏÎÏÎÏÏÏÏÎ ÏÎÏÎÎÎÎ ÏÎ "
+"ÏÏÏÎÏÏÎÏÎ (ÏÏ ÎÎÏÎÎ) ÎÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÎÎÏ ÎÎÎÏÎ."
+
+#: C/guitar-tuner.cpp.page:243(p)
+msgid ""
+"Now that we have set up the <em>E</em> button we also need to connect the "
+"other buttons according to their frequencies: 440 for A, 587.33 for D, "
+"783.99 for G, 987.77 for B and 1318.5 for the high E. This is done in the "
+"same way, just passing a different frequency to the handler."
+msgstr ""
+"ÎÏÏÎ ÏÎÏ ÏÏÎÎÎÏÎÎÎ ÏÎ ÎÎÏÎÏÎ <em>E</em> ÎÎ ÏÏÎÎÎÏÏÎÏÎÎ ÎÏÎÏÎÏ ÎÎ ÏÏÎÎÎÏÎÏÎÎ "
+"ÏÎ ÎÎÎÎ ÎÎÏÎÏÎÎ ÏÏÎÏÏÎÎ ÎÎ ÏÎÏ ÏÏÏÎÏÏÎÏÎÏ ÏÎÏÏ: 440 ÎÎÎ A, 587.33 ÎÎÎ D, "
+"783.99 ÎÎÎ G, 987.77 ÎÎÎ B ÎÎÎ 1318.5 ÎÎÎ ÏÎÎ ÏÏÎÎÎ Î. ÎÏÏÏ ÎÎÎÎÏÎÎ ÎÎ ÏÎÎ "
+"ÎÎÎÎ ÏÏÏÏÎ, ÎÏÎÎ ÏÎÏÎÏÎÏÎÏ ÎÎÎ ÎÎÎÏÎÏÎÏÎÎÎ ÏÏÏÎÏÏÎÏÎ ÏÏÎÎ ÏÎÎÏÎÏÏÎ."
+
+#: C/guitar-tuner.cpp.page:250(p)
+#| 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!"
+msgid ""
+"All of the code should now be ready to go. Click <guiseq><gui>Build</"
+"gui><gui>Build Project</gui></guiseq> to build everything again, and then "
+"<guiseq><gui>Run</gui><gui>Run</gui></guiseq> to start the application."
+msgstr ""
+"ÎÎÎÏ Î ÎÏÎÎÎÎÏ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÏÎÎÎÎÏ ÏÏÏÎ. ÎÎÎÎ "
+"<guiseq><gui>ÎÎÏÎÏÎÎÏÎ</gui><gui>ÎÎÏÎÏÎÎÏÎ ÎÏÎÎÏ</gui></guiseq> ÎÎÎ "
+"ÎÎÎÎÎÏÎÏÎÎÏÎ ÏÏÎ ÏÎÎÏÏÎ ÎÎÎ ÎÏÎÎÏÎ "
+"<guiseq><gui>ÏÏÎÎÎÎÎ</gui><gui>ÏÏÎÎÎÎÎ</gui></guiseq> ÎÎÎ ÎÎÎÏÎÎ ÏÎÏ "
+"ÎÏÎÏÎÎÎÎÏ."
+
+#: C/guitar-tuner.cpp.page:256(p)
+#| msgid ""
+#| "If you run into problems with the tutorial, compare your code with this "
+#| "<link href=\"guitar-tuner/guitar-tuner.py\">reference code</link>."
 msgid ""
 "If you run into problems with the tutorial, compare your code with this "
-"<link href=\"guitar-tuner/guitar-tuner.py\">reference code</link>."
+"<link href=\"guitar-tuner/guitar-tuner.cc\">reference code</link>."
 msgstr ""
-"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÎÎÎÎÎÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎÎ ÎÎÎÎÏ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ "
-"ÎÏÏÏ <link href=\"guitar-tuner/guitar-tuner.py\">ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÎÎÎÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏ "
+"ÏÎÎ <link href=\"guitar-tuner/guitar-tuner.cc\">ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+
+#: C/guitar-tuner.cpp.page:260(title)
+msgid "Further Reading"
+msgstr "ÎÎÏÎÎÏÎÏÏ ÎÎÎÎÎÏÏÎ"
+
+#: C/guitar-tuner.cpp.page:261(p)
+msgid ""
+"Many of the things shown above are explained in detail in the <link href="
+"\"http://library.gnome.org/devel/gtkmm-tutorial/stable/\";>GTKmm book</link> "
+"which also covers a lot more key concept for using the full power of GTKmm. "
+"You might also be interested in the <link href=\"http://library.gnome.org/";
+"devel/gstreamermm/\">GStreamermm reference documentation</link>."
+msgstr ""
+"ÎÎÎÎÎ ÎÏÏ ÏÎ ÏÏÎÎÎÎÏÎ ÏÎÏ ÎÎÏÎÎÎÏÏÎÎÎÎ ÏÎÏÎÏÎÎÏ ÎÎÎÎÎÏÎÏÎÎ ÎÎ ÎÎÏÏÎÎÎÏÎÎÎ "
+"ÏÏÎ <link href=\"http://library.gnome.org/devel/gtkmm-";
+"tutorial/stable/\">ÎÎÎÎÎÎ GTKmm</link> ÏÎÏ ÎÏÎÏÎÏ ÎÎÎÏÏÏÎÎ ÏÎÎÏ ÏÎÏÎÏÏÏÏÎÏÎÏ "
+"ÎÎÏÎÎÎÏ ÎÎÎÎÎÎÏ ÏÏÎÏÎÏ ÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎÏ ÏÎÏ GTKmm. ÎÏÏÏ ÎÏÎÏÎÏ ÎÎÎÎÎÏÎÏÎÏÏÎ "
+"ÎÎÎ ÏÎÎ <link href=\"http://library.gnome.org/devel/gstreamermm/\";>ÏÎÎÎÎÏÎÏÏÎ "
+"ÎÎÎÏÎÏÎÏ GStreamermm</link>."
+
+#: C/guitar-tuner.c.page:34(p)
+#| msgid "Basic knowledge of the python programming language"
+msgid "Basic knowledge of the C programming language"
+msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ C"
+
+#: C/guitar-tuner.c.page:48(p)
+#| 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."
+msgid ""
+"Choose <gui>Gtk+ (Simple)</gui> from the <gui>C</gui> tab, click "
+"<gui>Continue</gui>, and fill out your details on the next few pages. Use "
+"<file>guitar-tuner</file> as project name and directory."
+msgstr ""
+"ÎÏÎÎÎÎÏÎ <gui>Gtk+ (ÎÏÎÏ)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>C</gui>, ÏÎÏÎÏÏÎ "
+"<gui>ÏÏÎÎÏÎÎÎ</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÏÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
+"ÎÎÎÎÏ ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ <file>guitar-tuner</file> ÏÏ ÏÎÎÎÎ ÏÎÏ "
+"ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÎÎÏÎÎÏÎÎÏ."
+
+#: C/guitar-tuner.c.page:51(p)
+msgid ""
+"Make sure that <gui>Configure external packages</gui> is switched <gui>ON</"
+"gui>. On the next page, select <em>gstreamer-0.10</em> from the list to "
+"include the GStreamer library in your project."
+msgstr ""
+"ÎÎÎÎÎÏÎÎÎÏÎ ÏÏÎ ÏÎ <gui>ÏÏÎÎÎÏÎ ÎÎÏÏÎÏÎÎÏÎ ÏÎÎÎÏÏÎ</gui> ÎÎÎÎÎ "
+"<gui>ÎÎÎÏÎÏ</gui>. ÎÏÎÎ ÎÏÏÎÎÎÎ ÏÎÎÎÎÎ, ÎÏÎÎÎÎÏÎ <em>gstreamer-0.10</em> ÎÏÏ "
+"ÏÎ ÎÎÏÏÎ ÎÎÎ ÏÏÎÏÎÏÎÎÎÏÎ ÏÎÏ ÎÎÎÎÎÎÎÎÎÎÏ GStreamer ÏÏÎ ÎÏÎÎ ÏÎÏ."
+
+#: C/guitar-tuner.c.page:65(p)
+#| 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:"
+msgid ""
+"C is a rather verbose language, so don't be surprised that the file contains "
+"quite a lot of code. Most of it 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 ""
+"Î C ÎÎÎÎÎ ÎÎÎ ÎÎÎÎÎÎ ÎÎÎÎÏÏÎÎÎ ÎÎÏÏÏÎ, ÎÏÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÏÎ ÏÎÏ ÏÎ ÎÏÏÎÎÎ "
+"ÏÎÏÎÎÏÎÎ ÏÎÎÏ ÎÏÎÎÎÎ. Î ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÏÏÏÏÏÏÎ ÎÏÎÎÎÎ. ÎÎÏÏÏÎÎÎ "
+"ÎÎÎ (ÎÎÎÏ) ÏÎÏÎÎÏÏÎ ÎÏÏ ÏÎÎ ÏÎÏÎÎÏÎÏÎ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÎÎÎÎÎ. "
+"ÎÎÏÎÏÏÏÏÎÏÎÏ ÎÎÏÏÎÎÎÏÎÎÎÏ ÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÏÏÂ ÏÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎ ÎÎÏÏÎ ÎÎ "
+"ÎÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎ ÎÎÏÎÎÎ:"
+
+#: C/guitar-tuner.c.page:72(p)
+msgid ""
+"The <code>create_window</code> function creates a new window by opening a "
+"GtkBuilder file (<file>src/guitar-tuner.ui</file>, defined a few lines "
+"above), connecting its signals and then displaying it in a window. The "
+"GtkBuilder file contains a description of a user interface and all of its "
+"elements. You can use Anjuta's editor to design GtkBuilder user interfaces."
+msgstr ""
+"Î ÏÏÎÎÏÏÎÏÎ <code>create_window</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÎ ÏÎÏÎÎÏÏÎ "
+"ÎÎÎÎÎÎÎÏÎÏ ÎÎÎ ÎÏÏÎÎÎ GtkBuilder (<file>src/guitar-tuner.ui</file>, ÏÎÏ "
+"ÎÏÎÎÎÏÎÎ ÎÎÎÎÏ ÎÏÎÎÎÎÏ ÏÎÏÎÏÎÎÏ), ÏÏÎÎÎÎÎÏÎÏ ÏÎ ÏÎÎÎÏÎ ÏÎÏ ÎÎÎ ÎÏÎÎÏÎ "
+"ÎÎÏÎÎÎÎÎÎÏÎÏ ÏÎ ÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÏÏ ÏÎ ÎÏÏÎÎÎ GtkBuilder ÏÎÏÎÎÏÎÎ ÎÎÎ "
+"ÏÎÏÎÎÏÎÏÎ ÎÎÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÎÎÎ ÏÎÏÎ ÏÏÎ ÏÏÎÎÏÎÎÏÎ ÏÎÏ. ÎÏÎÏÎÎÏÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎÎ ÎÏÎÎÎÏÎÎÏÏÎ ÏÎÏ Anjuta ÎÎÎ ÏÏÎÎÎÎÏÎ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ "
+"GtkBuilder."
+
+#: C/guitar-tuner.c.page:121(p)
+#| 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:"
+msgid ""
+"To do this, open <file>main.c</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 at a position that is outside any "
+"function. The following code will be added to your source file:"
+msgstr ""
+"ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÎÎÎÎÎÏÎ ÏÎ <file>main.c</file>, ÎÏÎÎÏÎÏ ÎÎÎÎÏÏÏ ÎÎÎ "
+"ÏÎ ÎÏÏÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ. ÎÎÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>ÏÎÎÎÏÎ</gui> ÏÎÏ "
+"ÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÎÏÎÏÎÏÎ ÏÎ ÏÎÎÎÎ ÏÎÏ ÏÎÎÎÏÎÏ. ÎÏÏÎ ÏÎÏÏÎ ÏÎ "
+"ÎÏÎÎÎÎ ÏÏÎÏ ÎÎÏÎÏÎ ÎÏÎÏÎÎ ÏÎ ÏÎÎÎ <gui>ÏÎÏÎÎÎÎÎ</gui> ÎÎÎ ÏÏÏÎÏÎ ÏÎÎ ÏÏÎ "
+"ÏÎÎÎÎÎ ÎÏÏÎÎÎ ÏÎ ÎÎÎ ÎÎÏÎ ÏÎÏ ÎÎÎÎÎ ÎÎÏ ÎÏÏ ÎÎÎÎ ÏÏÎÎÏÏÎÏÎ. Î ÎÎÏÎÎÏÎÎÏ "
+"ÎÏÎÎÎÎÏ ÎÎ ÏÏÎÏÏÎÎÎÎ ÏÏÎ ÏÎÎÎÎÎ ÎÏÏÎÎÎ:"
+
+#: C/guitar-tuner.c.page:129(p)
+msgid ""
+"This signal handler has two arguments: a pointer to the <code>GtkWidget</"
+"code> that called the function (in our case, always a <code>GtkButton</"
+"code>), and a pointer to some \"user data\" that you can define, but which "
+"we won't be using here. (You can set the user data by calling "
+"<code>gtk_builder_connect_signals</code>; it is normally used to pass a "
+"pointer to a data structure that you might need to access inside the signal "
+"handler.)"
+msgstr ""
+"ÎÏÏÏÏ Î ÏÎÎÏÎÏÏÎÏ ÏÎÎÎÏÎÏ ÎÏÎÎ ÎÏÎ ÎÏÎÏÎÎÏÎ: ÎÎÎ ÎÎÎÎÏÎ ÏÏÎ "
+"<code>GtkWidget</code> ÏÎÏ ÎÎÎÎÏÎ ÏÎ ÏÏÎÎÏÏÎÏÎ (ÏÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÏ, ÏÎÎÏÎÏÎ "
+"ÎÎÎ <code>GtkButton</code>) ÎÎÎ ÎÎÎ ÎÎÎÎÏÎ ÏÏÎ ÎÎÏÎÎÎ \"ÎÎÎÎÎÎÎÎ ÏÏÎÏÏÎ\" ÏÎÏ "
+"ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÏÎÏÎ, ÎÎÎÎ ÏÎ ÎÏÎÎÎ ÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÏ. (ÎÏÎÏÎÎÏÎ ÎÎ "
+"ÎÏÎÏÎÏÎ ÏÎ ÎÎÎÎÎÎÎÎ ÏÏÎÏÏÎ ÎÎÎÏÎÏÎÏ "
+"<code>gtk_builder_connect_signals</code>; ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÏÎ "
+"ÏÎÏÎÏÎÎ ÎÎÏÏ ÎÎÎÎÏÎ ÏÎ ÎÎÎ ÎÎÎÎ ÎÎÎÎÎÎÎÏÎ ÏÎÏ ÎÏÏÏ ÏÏÎÎÎÏÏÎÎÏÎ ÎÎ "
+"ÏÏÎÏÏÎÎÎÏÎÏÎ ÏÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÎÏ.)"
+
+#: C/guitar-tuner.c.page:147(p)
+msgid ""
+"Insert the following line into <file>main.c</file>, just below the <code><!"
+"[CDATA[#include <gtk/gtk.h>]]></code> line:"
+msgstr ""
+"ÎÎÏÎÎÎÏÎ ÏÎÎ ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎ ÏÏÎ <file>main.c</file>, ÎÎÏÎÎÏÏ ÎÎÏÏ ÎÏÏ ÏÎ "
+"ÎÏÎÎÎÎ <code><![CDATA[#include <gtk/gtk.h>]]></code>:"
+
+#: C/guitar-tuner.c.page:149(p)
+#| 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:"
+msgid ""
+"This includes the GStreamer library. You also need to add a line to "
+"initialize GStreamer; put the following code on the line above the "
+"<code>gtk_init</code> call in the <code>main</code> function:"
+msgstr ""
+"ÎÏÏÏ ÏÎÏÎÎÎÎÎÎÎÎÎ ÏÎ ÎÎÎÎÎÎÎÎÎÎ ÏÎÏ GStreamer. ÎÏÎÎÎÎÎÏÎÎ ÎÏÎÏÎÏ ÎÎ "
+"ÏÏÎÏÎÎÏÎÏÎÎ ÎÎÎ ÎÏÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎÏÎÎÎÏÎ ÏÎÏ GStreamer ÎÎÎÏÎ ÏÎÎ ÏÎÏÎÎÎÏÏ "
+"ÎÏÎÎÎÎ ÏÏÎÎ ÎÏÎÎÎÎ ÏÎÎÏ ÎÏÏ ÏÎÎ ÎÎÎÏÎ <code>gtk_init</code> ÏÏÎ ÏÏÎÎÏÏÎÏÎ "
+"<code>main</code>:"
+
+#: C/guitar-tuner.c.page:151(p)
+#| msgid ""
+#| "Then, copy the following function into the main class in "
+#| "<file>guitar_tuner.py</file> somewhere:"
+msgid ""
+"Then, copy the following function into <file>main.c</file> above the empty "
+"<code>on_button_clicked</code> function:"
+msgstr ""
+"ÎÎÏÎ, ÎÎÏÎÎÏÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÏÏÎÎÏÏÎÏÎ ÏÏÎÎ <file>main.c</file> ÏÎÎÏ ÎÏÏ "
+"ÏÎÎ ÎÎÎÎ ÏÏÎÎÏÏÎÏÎ <code>on_button_clicked</code>:"
+
+#: C/guitar-tuner.c.page:178(p)
+#| 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)."
+msgid ""
+"The first five lines create source and sink GStreamer elements "
+"(<code>GstElement</code>), 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 ""
+"ÎÎ ÏÏÎÎÏ ÏÎÎÏÎ ÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ ÏÎÎÎ ÎÎÎ ÎÎÎÎÎÏ ÏÎÏ GStreamer "
+"(<code>GstElement</code>) ÎÎÎ ÎÎÎ ÏÏÎÎÏÎÎÎ ÏÏÎÎÎÏÏÎÏ (ÏÎ ÎÏÎÎÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ ÏÏ ÏÎÏÎÎÎÏÎÏ ÎÎÎ ÏÎ ÎÏÎ ÎÎÎÎ ÏÏÎÎÏÎÎÎ). ÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎÎ "
+"\"note\" ÏÏÎ ÏÏÎÎÎÏÏÎÂ ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÏÎÎÎ \"source\" ÎÎÎ ÏÎ ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎ "
+"<code>audiotestsrc</code>Â ÎÎÎ ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ \"output\" ÎÎÎ ÏÎÎ "
+"ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÎÎÎ <code>autoaudiosink</code> (ÏÏÎÎÏÎÎÎÎÎÎÎÎ ÎÎÎÎÎÏ ÎÎÏÏÎÏ "
+"ÎÏÎÏ)."
+
+#: C/guitar-tuner.c.page:181(p)
+#| 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."
+msgid ""
+"The call to <code>g_object_set</code> sets the <code>freq</code> property of "
+"the source element to <code>frequency</code>, which is passed as an argument "
+"to the <code>play_sound</code> function. This is just the frequency of the "
+"note in Hertz; some useful frequencies will be defined later on."
+msgstr ""
+"ÎÎ ÎÎÎÎÏÎÎ ÏÎÏ <code>g_object_set</code> ÎÏÎÎÎÎ ÏÎÎ ÎÎÎÏÏÎÏÎ "
+"<code>freq</code> ÏÎÏ ÏÏÎÎÏÎÎÎÏ ÏÎÎÎ ÏÎ <code>frequency</code>, Î ÎÏÎÎÎ ÎÏÎÎ "
+"ÏÎÏÎÏÏÎÎ ÏÏ ÏÏÎÏÎÎ ÏÏÎ ÏÏÎÎÏÏÎÏÎ <code>play_sound</code>. ÎÏÏÎ ÎÎÎÎÎ ÎÏÎÎ Î "
+"ÏÏÏÎÏÏÎÏÎ ÏÎÏ ÎÏÏÎÏ ÏÎ Hertz ÎÎÏÎÎÎÏ ÏÏÎÏÎÎÎÏ ÏÏÏÎÏÏÎÏÎÏ ÎÎ ÎÏÎÏÏÎÏÎ "
+"ÎÏÎÏÏÎÏÎ."
+
+#: C/guitar-tuner.c.page:184(p)
+#| 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."
+msgid ""
+"<code>gst_bin_add_many</code> puts the source and sink into the pipeline. "
+"The pipeline is a <code>GstBin</code>, which is just an element that can "
+"contain multiple other GStreamer elements. In general, you can add as many "
+"elements as you like to the pipeline by adding more arguments to "
+"<code>gst_bin_add_many</code>."
+msgstr ""
+"Î <code>gst_bin_add_many</code> ÎÎÎÎÎ ÏÎÎ ÏÎÎÎ ÎÎÎ ÏÎÎ ÎÎÎÎÎ ÏÏÎ ÏÏÎÎÎÏÏÎ. Î "
+"ÏÏÎÎÎÏÏÎ ÎÎÎÎÎ ÎÎÎÏ <code>GstBin</code>, ÏÎÏ ÎÎÎÎÎ ÎÏÎÎÏ ÎÎÎ ÏÏÎÎÏÎÎÎ ÏÎÏ "
+"ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÏÎÎÎÎÏÎÎ ÎÎÎÎ ÏÏÎÎÏÎÎÎ GStreamer. ÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ "
+"ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ ÏÏÎÎÏÎÎÎ ÎÎÎÎÏÎ ÏÏÎ ÏÏÎÎÎÏÏÎ ÏÏÎÏÎÎÏÎÎÏÎÏ ÏÎÏÎÏÏÏÏÎÏÎ "
+"ÎÏÎÏÎÎÏÎ ÏÏÎÎ <code>gst_bin_add_many</code>."
+
+#: C/guitar-tuner.c.page:187(p)
+msgid ""
+"Next, <code>gst_element_link</code> is used to connect the elements "
+"together, so the output of <code>source</code> (a tone) goes into the input "
+"of <code>sink</code> (which is then output to the sound card). "
+"<code>gst_element_set_state</code> is then used to start playback, by "
+"setting the state of the pipeline to playing (<code>GST_STATE_PLAYING</"
+"code>)."
+msgstr ""
+"ÎÎÏÏÏÎÎ, Î <code>gst_element_link</code> ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÎ ÏÏÎÎÎÏÎ ÏÏÎ "
+"ÏÏÎÎÏÎÎÏÎ ÎÎÎÎ, ÎÏÏÎ Î ÎÎÎÎÎÏ ÏÎÏ <code>source</code> (ÎÎÎÏ ÏÏÎÎÏ) ÏÎÎÎÎÎÎÎ "
+"ÏÏÎÎ ÎÎÏÎÎÎ ÏÎÏ <code>sink</code> (ÏÎÏ ÎÎÎÎÎ ÎÏÎÎÏÎ ÎÎÎÎÎÏ ÏÏÎÎ ÎÎÏÏÎ ÎÏÎÏ). "
+"ÎÎ <code>gst_element_set_state</code> ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÏÎÎÏÎ ÎÎÎ ÎÎÎÏÎÎ "
+"ÎÎÎÏÎÏÎÎÏÎÎÏ, ÎÏÎÎÎÎÏÎÏ ÏÎÎ ÎÎÏÎÏÏÎÏÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ ÎÎ ÏÎÎÎÎÎ "
+"(<code>GST_STATE_PLAYING</code>)."
+
+#: C/guitar-tuner.c.page:195(p)
+#| 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>."
+msgid ""
+"We don't want to play an annoying tone forever, so the last thing "
+"<code>play_sound</code> does is to call <code>g_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>g_timeout_add</code>. ÎÏÏÏ ÎÏÎÎÎÎ ÎÎÎ ÏÏÎÎÎÎÏ ÏÎÏÎÎÏÏÎÎ ÏÎÏ ÎÎ "
+"ÏÏÎÎÎÏÎÏÎÎ ÏÎÎ ÎÏÎÂ ÏÎÏÎÎÎÎÎÎ ÎÎÎ <code>LENGTH</code> ms ÏÏÎÎ ÎÎÎÎÏÎÎ ÏÎ "
+"ÏÏÎÎÏÏÎÏÎ <code>pipeline_stop</code>, ÎÎÎ ÎÎ ÏÏÎÎÏÎÏÎÎ ÎÎ ÏÎÎ ÎÎÎÎÎ ÎÎÏÏÎ Î "
+"<code>pipeline_stop</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ <code>False</code>."
+
+#: C/guitar-tuner.c.page:196(p)
+#| 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:"
+msgid ""
+"Now, we'll write the <code>pipeline_stop</code> function which is called by "
+"<code>g_timeout_add</code>. Insert the following code <em>above</em> the "
+"<code>play_sound</code> function:"
+msgstr ""
+"ÎÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ <code>pipeline_stop</code>, Î ÎÏÎÎÎ ÎÎÎÎÎÏÎÎ "
+"ÎÏÏ ÏÎ <code>g_timeout_add</code>. ÎÏÎÏÎÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÎÎÎ "
+"<em>ÏÎÎÏ</em> ÎÏÏ ÏÎ ÏÏÎÎÏÏÎÏÎ <code>play_sound</code>:"
+
+#: C/guitar-tuner.c.page:208(p)
+msgid ""
+"The call to <code>gst_element_set_state</code> pauses the playback of the "
+"pipeline and <code>g_object_unref</code> unreferences the pipeline, "
+"destroying it and freeing its memory."
+msgstr ""
+"Î ÎÎÎÏÎ ÏÎ <code>gst_element_set_state</code> ÏÏÎÎÎÏÎ ÏÎÎ ÎÎÎÏÎÏÎÎÏÎÎ ÏÎÏ "
+"ÏÏÎÎÎÏÏÎÏ ÎÎÎ Î <code>g_object_unref</code> ÏÏÎÎÎÏÎ ÏÎÎ ÎÎÎÏÎÏÎ ÏÏÎ "
+"ÏÏÎÎÎÏÏÎ, ÎÎÏÎÏÏÏÎÏÎÎÏÎÏ ÏÎÎ ÎÎÎ ÎÎÎÏÎÎÏÏÎÎÎÏÎÏ ÏÎ ÎÎÎÎÎ ÏÎÏ."
+
+#: C/guitar-tuner.c.page:213(p)
+#| 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:"
+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 top of <file>main.c</file>) as follows:"
+msgstr ""
+"ÎÎÎÎÏÎÎ ÎÎ ÏÎÎÎÎÏÎÎ ÏÎ ÏÏÏÏÏ ÎÏÎ ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎ ÎÎÎ ÎÎÏÎÏÎ. ÎÏÏÏÎ ÎÏÏ "
+"ÏÎÎ, ÎÎÎÎÏÎÎ ÎÎ ÎÎÏÎÏÎÎ ÏÎÏ ÏÏÏÎÏÏÎÏÎÏ ÎÎÎ ÏÎÏ ÎÎÎ ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ, ÎÎ "
+"ÎÏÎÎÎÏ ÎÏÎÎÎÎÏÎÎ (ÏÏÎÎ ÎÏÏÎ ÏÎÏ <file>main.c</file>) ÏÏ ÎÎÎÎÎÏÎÏÏ:"
+
+#: C/guitar-tuner.c.page:245(p)
+#| 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>."
+msgid ""
+"A pointer to the <code>GtkButton</code> 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>gtk_bin_get_child</code>, and then "
+"get the text from that label using <code>gtk_label_get_label</code>."
+msgstr ""
+"Î ÎÎÎÎÏÎÏ ÏÏÎ <code>Gtk.Button</code> ÏÎÏ ÏÎÏÎÎÎÎÎ ÏÎÏÎÎ ÏÏ ÏÏÎÏÎÎ "
+"(<code>button</code>) ÏÏÎ <code>on_button_clicked</code>. ÎÏÎÏÎÏÎÎ ÎÎ "
+"ÏÎÏÎÏÎÎ ÏÎÎ ÎÏÎÎÎÏÎ ÎÏÏÎÏ ÏÎÏ ÎÎÏÎÏÎÎÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ "
+"<code>gtk_bin_get_child</code> ÎÎÎ ÎÏÎÎÏÎ ÎÎ ÏÎÏÎÏÎÎ ÏÎ ÎÎÎÎÎÎÎ ÎÏÏ ÎÏÏÎÎ "
+"ÏÎÎ ÎÏÎÎÎÏÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ <code>gtk_label_get_label</code>."
+
+#: C/guitar-tuner.c.page:246(p)
+#| 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!"
+msgid ""
+"The label text is then compared to the notes that we have using "
+"<code>g_str_equal</code>, 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>g_str_equal</code> ÎÎÎ <code>play_sound</code> ÎÎÎÎÎÏÎÎ ÎÎ ÏÎÎ "
+"ÎÎÏÎÎÎÎÎÎ ÏÏÏÎÏÏÎÏÎ ÎÎÎ ÎÏÏÎÎ ÏÎÎ ÎÏÏÎ. ÎÏÏÏ ÏÎÎÎÎÎ ÏÎÎ ÏÏÎÎÂ Î ÏÏÎÏÎÎÎÏÏÎÏ "
+"ÎÎÎÎÏÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ!"
+
+#: C/guitar-tuner.c.page:257(p)
+#| msgid ""
+#| "If you run into problems with the tutorial, compare your code with this "
+#| "<link href=\"guitar-tuner/guitar-tuner.py\">reference code</link>."
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"guitar-tuner/guitar-tuner.c\">reference code</link>."
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÎÎÎÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÎ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏ "
+"ÏÎÎ <link href=\"guitar-tuner/guitar-tuner.c\">ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
+
+#: C/GtkApplicationWindow.vala.page:16(desc)
+#: C/GtkApplicationWindow.py.page:16(desc)
+#: C/GtkApplicationWindow.js.page:16(desc)
+msgid "GtkWindow subclass with GtkApplication support"
+msgstr "Î ÏÏÎÎÎÎÏÎ GtkWindow ÎÎ ÏÏÎÏÏÎÏÎÎÎ GtkApplication"
+
+#: C/GtkApplicationWindow.vala.page:19(title)
+#: C/GtkApplicationWindow.py.page:19(title)
+#: C/GtkApplicationWindow.js.page:19(title)
+#: C/GtkApplicationWindow.c.page:19(title)
+msgid "ApplicationWindow"
+msgstr "ApplicationWindow"
+
+#: C/GtkApplicationWindow.vala.page:21(p) C/GtkApplicationWindow.py.page:21(p)
+msgid "The simplest GtkApplication Window which can support Menus."
+msgstr "ÎÎ ÎÏÎÎÏÏÏÎÏÎ ÏÎÏÎÎÏÏÎ GtkApplication ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÏÎÏÎÎÎÎ ÎÎÎÎÏ."
+
+#: C/GtkApplicationWindow.js.page:21(p)
+msgid "A simple GtkApplicationWindow which can support Menus."
+msgstr "ÎÎÎ ÎÏÎÏ GtkApplicationWindow ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÏÎÏÎÎÎÎ ÎÎÎÎÏ."
+
+#: C/GtkApplicationWindow.c.page:16(desc)
+msgid "A toplevel window which can contain other widgets, and support GMenu"
+msgstr ""
+"ÎÎÎ ÏÎÏÎÎÏÏÎ ÎÎÏÏÎÏÎÏ ÎÏÎÏÎÎÎÏ ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ "
+"ÎÎÎ ÏÏÎÏÏÎÏÎÎÎÎ GMenu"
+
+#: C/GtkApplicationWindow.c.page:21(p)
+msgid "A minimal GtkApplication with a GtkApplicationWindow"
+msgstr "ÎÎÎ ÎÎÎÏÎÏÏÎ GtkApplication ÎÎ ÎÎÎ GtkApplicationWindow"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/grid.vala.page:22(None) C/grid.py.page:21(None) C/grid.js.page:24(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+msgid "@@image: 'media/grid.png'; md5=27d45da115401127456a3b854dcfc5be"
+msgstr "@@image: 'media/grid.png'Â md5=27d45da115401127456a3b854dcfc5be"
+
+#: C/grid.vala.page:18(desc) C/grid.py.page:16(desc) C/grid.js.page:20(desc)
+msgid "Pack widgets in rows and columns"
+msgstr "ÎÎÎÎÏÎÏÎÏÎÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ ÏÎ ÎÏÎÎÎÎÏ ÎÎÎ ÏÏÎÎÎÏ"
+
+#: C/grid.vala.page:21(title) C/grid.py.page:19(title)
+#: C/grid.js.page:23(title)
+msgid "Grid widget"
+msgstr "ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÎÎÎÎÎÏÎÏ"
+
+#: C/grid.vala.page:23(p) C/grid.py.page:22(p)
+msgid "A button widget connected to a progress bar."
+msgstr "ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÎÏÎÏÎÎÏ ÏÏÎÎÎÎÎÎÎ ÎÎ ÎÎÎ ÎÏÎÎÎÎ ÏÏÎÏÎÎÏ."
+
+#: C/grid.vala.page:30(link) C/grid.py.page:32(link) C/grid.js.page:35(link)
+msgid "Gtk.Grid"
+msgstr "Gtk.Grid"
+
+#: C/grid.py.page:34(link) C/grid.js.page:34(link) C/button.js.page:31(link)
+msgid "Gtk.Button"
+msgstr "Gtk.Button"
+
+#: C/grid.js.page:25(p)
+msgid ""
+"A button widget connected to a progress bar, inside of a grid which handles "
+"the layout."
+msgstr ""
+"ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÎÏÎÏÎÎÏ ÏÏÎÎÎÎÎÎÎ ÎÎ ÎÎÎ ÎÏÎÎÎÎ ÏÏÎÏÎÎÏ, ÎÎÏÎ ÏÎ ÎÎÎ "
+"ÏÎÎÎÎÎ ÏÎÏ ÏÎÎÏÎÎÎÏÎÎ ÏÎ ÎÎÎÏÎÎÎ."
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/gmenu.vala.page:25(None)
+msgid "@@image: 'media/gmenu.vala.png'; md5=7a9f381fc3ed5bf8d1c50d2acb095400"
+msgstr "@@image: 'media/gmenu.vala.png'Â md5=7a9f381fc3ed5bf8d1c50d2acb095400"
+
+#: C/gmenu.vala.page:11(name) C/aboutdialog.vala.page:11(name)
+msgid "Ryan Lortie"
+msgstr "Ryan Lortie"
+
+#: C/gmenu.vala.page:12(email) C/aboutdialog.vala.page:12(email)
+msgid "desrt desrt ca"
+msgstr "desrt desrt ca"
+
+#: C/gmenu.vala.page:21(desc) C/gmenu.py.page:16(desc)
+#: C/gmenu.js.page:16(desc) C/gmenu.c.page:16(desc)
+msgid "A simple implementation of GMenuModel"
+msgstr "ÎÎÎ ÎÏÎÎ ÏÎÎÏÎÎÎÏÎ ÏÎÏ GMenuModel"
+
+#: C/gmenu.vala.page:27(em)
+msgid "You need to be running Gtk+-3.4 or later for this to work"
+msgstr "ÎÏÎÎÎÎÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎ ÏÎ Gtk+-3.4 Î ÎÎÏÎÎÎÎÎÏÏÎÏÎ ÎÎÎ ÎÏÏÎ ÏÎ ÎÎÏÎÎÎÎ"
+
+#: C/gmenu.vala.page:30(p)
+msgid ""
+"This program will not compile with the quit action connected until <link "
+"href=\"https://bugzilla.gnome.org/show_bug.cgi?id=674090\";>Bug #674090</"
+"link> is fixed. Therefore, the problematic line has been commented out."
+msgstr ""
+"ÎÏÏÏ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÎ ÎÎ ÏÎÎ ÎÎÎÏÎÎÎÎ ÎÎÎÎÏÎÎÎÎÏÎÏ "
+"ÏÏÎÎÎÎÎÎÎ ÎÎÏÏÎ ÏÎ ÏÏÎÎÎÏÎ ÏÎÏ <link "
+"href=\"https://bugzilla.gnome.org/show_bug.cgi?id=674090\";>Bug #674090</link>. "
+"ÎÏÎÎÏÏÏ, Î ÏÏÎÎÎÎÎÎÏÎÎÎ ÎÏÎÎÎÎ ÎÏÎÎ ÎÏÎÏÏÎÎÎÎÏÎÎÎ."
+
+#: C/gmenu.vala.page:32(p) C/gmenu.py.page:21(p) C/gmenu.js.page:21(p)
+#: C/gmenu.c.page:21(p)
+msgid "A GtkApplication with a simple GMenu and SimpleActions"
+msgstr "ÎÎÎ GtkApplication ÎÎ ÎÎÎ ÎÏÎÏ GMenu ÎÎÎ SimpleActions"
+
+#: C/gmenu.vala.page:41(link)
+msgid "Menu"
+msgstr "ÎÎÎÎÏ"
+
+#: C/gmenu.vala.page:42(link)
+msgid "append"
+msgstr "ÏÏÎÏÎÏÏÎÏÎ"
+
+#: C/gmenu.vala.page:43(link)
+msgid "SimpleAction"
+msgstr "SimpleAction"
+
+#: C/gmenu.vala.page:44(link)
+msgid "add_action"
+msgstr "add_action"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/gmenu.py.page:20(None)
+msgid "@@image: 'media/gmenu.py.png'; md5=52c68b34d5d566f37e9f803dedb6353a"
+msgstr "@@image: 'media/gmenu.py.png'Â md5=52c68b34d5d566f37e9f803dedb6353a"
+
+#: C/gmenu.py.page:22(em) C/gmenu.c.page:22(em) C/aboutdialog.vala.page:28(em)
+msgid "You need to be running Gtk3.4 or later for this to work"
+msgstr "ÎÏÎÎÎÎÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎ ÏÎ Gtk3.4 Î ÎÎÏÎÎÎÎÎÏÏÎÏÎ ÎÎÎ ÎÏÏÎ ÏÎ ÎÎÏÎÎÎÎ"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/gmenu.js.page:20(None)
+msgid "@@image: 'media/gmenu.js.png'; md5=16b8bee122197771ec8498dac42f196b"
+msgstr "@@image: 'media/gmenu.js.png'Â md5=16b8bee122197771ec8498dac42f196b"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/gmenu.c.page:20(None)
+msgid "@@image: 'media/gmenu.c.png'; md5=f305fc3cae8d16d72b734ee53b559e33"
+msgstr "@@image: 'media/gmenu.c.png'Â md5=f305fc3cae8d16d72b734ee53b559e33"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/getting-ready.page:39(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner-glade.png'; "
+#| "md5=f6606525443ab2160f53a87a454364d0"
+msgid "@@image: 'media/ubuntu.png'; md5=40845e4a40b335b1958da1403f01c13f"
+msgstr "@@image: 'media/ubuntu.png'Â md5=40845e4a40b335b1958da1403f01c13f"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/getting-ready.page:44(None)
+msgid "@@image: 'media/fedora.png'; md5=19add55f4349fd9e90f3a50b344ba626"
+msgstr "@@image: 'media/fedora.png'Â md5=19add55f4349fd9e90f3a50b344ba626"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/getting-ready.page:49(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner-pipeline.png'; "
+#| "md5=5adc952909d92af5dae6954781b4ad5f"
+msgid "@@image: 'media/opensuse.png'; md5=a852a94199328e2f978c7f6a55bf8b54"
+msgstr "@@image: 'media/opensuse.png'Â md5=a852a94199328e2f978c7f6a55bf8b54"
+
+#: C/getting-ready.page:6(title)
+msgid "Install GNOME development tools"
+msgstr "ÎÎÎÎÏÎÏÏÎÏÎ ÎÏÎÎÎÎÎÏÎ ÎÎÎÏÏÏÎÎÏ GNOME"
+
+#: C/getting-ready.page:16(title)
+msgid "Getting ready for GNOME development"
+msgstr "ÎÏÎÎÎÎÏÎÎ ÎÎÎ ÎÎÎÏÏÏÎÎ GNOME"
+
+#: C/getting-ready.page:19(title)
+msgid "Install the required tools"
+msgstr "ÎÎÎÎÏÎÏÏÎÏÎ ÏÏÎ ÎÏÎÎÏÎÏÎÎÎÏÎ ÎÏÎÎÎÎÎÏÎ"
+
+#: C/getting-ready.page:20(p)
+msgid ""
+"Before you can start coding you will have to install the required tools for "
+"GNOME development on your computer. This shouldn't take you more than ten "
+"minutes."
+msgstr ""
+"ÎÏÎÎ ÎÎ ÎÏÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÎÎÏÎÏÎ ÏÎÎ ÎÏÎÎÎÎÏÎÎÎÏÎ ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÏÎÏÏÎÏÎÏÎ "
+"ÏÎ ÎÏÎÎÏÎÏÎÎÎÎ ÎÏÎÎÎÎÎÎ ÎÎÎ ÏÎÎ ÎÎÎÏÏÏÎÎ ÏÎÏ GNOME ÏÏÎÎ ÏÏÎÎÎÎÎÏÏÎ ÏÎÏ. ÎÏÏÏ "
+"ÎÎÎ ÏÏÎÏÎÎ ÎÎ ÏÎÏÎÎ ÏÎÎÏ ÎÏÏ ÎÎÎÎ ÎÎÏÏÎ."
+
+#: C/getting-ready.page:25(title)
+msgid "Automatic installation"
+msgstr "ÎÏÏÏÎÎÏÎ ÎÎÎÎÏÎÏÏÎÏÎ"
+
+#: C/getting-ready.page:26(p)
+msgid ""
+"On an up-to-date distribution you should be able to simply install the "
+"required packages by clicking on <link href=\"media/gnome-devtools.catalog"
+"\">Install now</link>."
+msgstr ""
+"ÎÎ ÎÎÎ ÎÎÎÎÎÏÏÎÎÎÎ ÎÎÎÎÎÎÎ ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎÏÎÏÏÎÏÎÏÎ ÎÏÎÎ ÏÎ "
+"ÎÏÎÎÏÎÏÎÎÎÎ ÏÎÎÎÏÎ ÎÎ ÎÎÎÎ ÏÏÎ <link href=\"media/gnome-"
+"devtools.catalog\">ÎÎÎÎÏÎÏÏÎÏÎ ÏÏÏÎ</link>."
+
+#: C/getting-ready.page:31(title)
+msgid "Manual installation"
+msgstr "ÎÎÎÏÎÎÎÎÎÏÎ ÎÎÎÎÏÎÏÏÎÏÎ"
+
+#: C/getting-ready.page:32(p)
+msgid ""
+"If you prefer manual installation you can find the instructions for the "
+"various distributions in the <link href=\"http://live.gnome.org/";
+"DeveloperTools/Installation\">GNOME wiki</link>. Click on the image to go "
+"directly to the installation page for your distribution:"
+msgstr ""
+"ÎÎ ÏÏÎÏÎÎÎÏÎ ÏÎÎÏÎÎÎÎÎÏÎ ÎÎÎÎÏÎÏÏÎÏÎ ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÏÎ ÎÎÎÎÎÎÏ ÎÎÎ ÏÎÏ "
+"ÏÎÎÎÎÎÎÏ ÎÎÎÎÎÎÎÏ ÏÏÎ <link "
+"href=\"http://live.gnome.org/DeveloperTools/Installation\";>ÎÎÎÎ GNOME</link>. "
+"ÎÎÏÎÏÏÎ ÏÏÎÎ ÎÎÎÏÎÎ ÎÎÎ ÎÎ ÏÎÏÎ ÎÎÎÏÎ ÏÏÎ ÏÎÎÎÎÎ ÎÎÎÎÏÎÏÏÎÏÎÏ ÎÎÎ ÏÎ ÎÎÎÎÎÎÎ "
+"ÏÎÏ:"
+
+#: C/getting-ready.page:39(media)
+msgid "Ubuntu"
+msgstr "Ubuntu"
+
+#: C/getting-ready.page:44(media)
+msgid "Fedora"
+msgstr "Fedora"
+
+#: C/getting-ready.page:49(media)
+msgid "OpenSuSE"
+msgstr "OpenSuSE"
+
+#: C/getting-ready.page:52(link)
+msgid "Others"
+msgstr "ÎÎÎÎ"
+
+#: C/getting-ready.page:59(title)
+msgid "Required versions"
+msgstr "ÎÏÎÎÏÎÏÎÎÎÎÏ ÎÎÎÏÏÎÎÏ"
+
+#: C/getting-ready.page:60(p)
+msgid ""
+"The guides assume that you have at least the following versions of the tools "
+"installed:"
+msgstr ""
+"ÎÎ ÎÎÎÎÎÎ ÏÏÎÎÎÏÎÏÎ ÏÏÎ ÎÏÎÏÎ ÏÎÏÎÎÏÎÏÏÎÎ ÏÎÏ ÏÎÏÎÎÎÏÏ ÎÎÎÏÏÎÎÏ ÏÏÎ "
+"ÎÏÎÎÎÎÎÏÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎÏ:"
+
+#: C/getting-ready.page:63(p)
+msgid "Anjuta - 3.0"
+msgstr "Anjuta - 3.0"
+
+#: C/getting-ready.page:64(p)
+msgid "Devhelp - 3.0"
+msgstr "Devhelp - 3.0"
+
+#: C/getting-ready.page:65(p)
+msgid "Glade - 3.10"
+msgstr "Glade - 3.10"
+
+#: C/getting-ready.page:67(p)
+msgid ""
+"Of course, any newer version will also work. Now, we wish you a lot of fun "
+"with the <link xref=\"index\">Demos</link>."
+msgstr ""
+"ÎÏÏÎÎÎ, ÎÏÎÎÎÎÎÏÎÏÎ ÎÎÏÏÎÏÎ ÎÎÎÎÏÎ ÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÏÎÏ. ÎÏÏÎ, ÏÎÏ ÎÏÏÏÎÎÏÏÎ "
+"ÏÎÎÏ ÎÎÎÏÎÎÎÎÏÎ ÎÎ ÏÎÎ <link xref=\"index\">ÏÎÏÎÏÏÎÎÏÎÎÏ</link>."
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/entry.vala.page:20(None) C/entry.py.page:20(None)
+msgid "@@image: 'media/entry.png'; md5=8a828cffdcbaa4bad83342e109f28cc8"
+msgstr "@@image: 'media/entry.png'Â md5=8a828cffdcbaa4bad83342e109f28cc8"
+
+#: C/entry.vala.page:16(desc) C/entry.py.page:16(desc)
+msgid "A single line text entry field"
+msgstr "ÎÎÎ ÏÎÎÎÎ ÎÎÏÎÏÏÏÎÏÎÏ ÎÎÎÎÎÎÎÏ ÎÎÎÎÎÎÎÎÏ ÎÏÎÎÎÎÏ"
+
+#: C/entry.vala.page:19(title) C/entry.py.page:19(title)
+msgid "Entry"
+msgstr "ÎÎÏÎÏÏÏÎÏÎ"
+
+#: C/entry.vala.page:21(p)
+msgid "This application greets you in the terminal."
+msgstr "ÎÏÏÎ Î ÎÏÎÏÎÎÎÎ ÏÎÏ ÏÎÎÏÎÏÎ ÏÏÎÎ ÏÎÏÎÎÏÎÎÏ."
+
+#: C/entry.vala.page:28(link)
+msgid "Gtk.Entry"
+msgstr "Gtk.Entry"
+
+#: C/entry.py.page:21(p)
+msgid "This application greets you in the terminal with the name you provide."
+msgstr "ÎÏÏÎ Î ÎÏÎÏÎÎÎÎ ÏÎÏ ÏÎÎÏÎÏÎ ÏÏÎÎ ÏÎÏÎÎÏÎÎÏ ÎÎ ÏÎ ÏÎÎÎÎ ÏÎÏ ÎÏÏÎÏÎ."
+
+#: C/entry.py.page:28(link)
+msgid "GtkEntry"
+msgstr "GtkEntry"
+
+#: C/documentation.page:19(title)
+msgid "Help develop"
+msgstr "ÎÎÎÎÎÎÎ ÎÎÎÏÏÏÎÎÏ"
+
+#: C/documentation.page:20(p)
+msgid ""
+"The <app>GNOME Developer Tutorials</app> are developed and maintained by a "
+"volunteer community. You are welcome to participate."
+msgstr ""
+"ÎÎ <app>ÎÎÎÎÎÎÏÎ ÎÎÎÏÏÏÎÎÏ ÏÎÏ GNOME</app> ÎÎÎÏÏÏÏÏÎÎÏÎÎ ÎÎÎ ÏÏÎÏÎÏÎÏÎÏÎÎ "
+"ÎÏÏ ÎÎÎ ÎÎÎÎÎÎÏÎÎÎ ÎÎÎÎÏÏÎÏÎ. ÎÎÏÎÏÏÎ ÎÎÎÎÎÎÏÎÏÎÎÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÏÎÏÎ."
+
+#: C/documentation.page:23(p)
+msgid ""
+"If you would like to <link href=\"https://live.gnome.org/";
+"DocumentationProject/Tasks/DeveloperDocs\">help develop <app>GNOME Developer "
+"Tutorials</app></link>, you can get in touch with the developers using <link "
+"href=\"https://cbe005.chat.mibbit.com/?url=irc%3A%2F%2Firc.gnome.org%2Fdocs";
+"\">irc</link>, or via our <link href=\"http://mail.gnome.org/mailman/";
+"listinfo/gnome-doc-devel-list\">mailing list</link>."
+msgstr ""
+"ÎÎÎ ÎÎÎÎÏÎ ÏÎÎ <link href=\"https://live.gnome.org/DocumentationProject/Tasks";
+"/DeveloperDocs\">ÎÎÎÎÎÎÎ ÎÎÎÏÏÏÎÎÏ<app>ÎÎÎÎÎÎÏÏÎ ÎÎÎÏÏÏÎÎÏ ÏÎÏ GNOME "
+"</app></link>, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÏÎ ÏÎ ÎÏÎÏÎ ÎÎ ÏÎÏÏ ÏÏÎÎÏÎÎÎÎÏÎÏÏÎÏ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ <link href=\"https://cbe005.chat.mibbit.com/?url=irc%3A%2F%";
+"2Firc.gnome.org%2Fdocs\">irc</link>, Î ÎÎÏÎ ÎÏÏ ÏÎÎ <link "
+"href=\"http://mail.gnome.org/mailman/listinfo/gnome-doc-devel-";
+"list\">ÏÎÏÏÎÏÎÎÎÎÎ ÎÎÏÏÎ</link>."
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/dialog.vala.page:20(None) C/dialog.py.page:20(None)
+#: C/dialog.js.page:20(None)
+#| msgid ""
+#| "@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+msgid "@@image: 'media/dialog.png'; md5=c90a33386a600e892fe623d4072c8c38"
+msgstr "@@image: 'media/dialog.png'Â md5=c90a33386a600e892fe623d4072c8c38"
+
+#: C/dialog.vala.page:16(desc) C/dialog.py.page:16(desc)
+#: C/dialog.js.page:16(desc)
+msgid "A popup window"
+msgstr "ÎÎÎ ÎÎÎÎÏÏÎÎÎÎ ÏÎÏÎÎÏÏÎ"
+
+#: C/dialog.vala.page:19(title) C/dialog.py.page:19(title)
+#: C/dialog.js.page:19(title)
+msgid "Dialog"
+msgstr "ÎÎÎÎÎÎÎÏ"
+
+#: C/dialog.vala.page:21(p) C/dialog.py.page:21(p)
+msgid "A dialog with the response signal hooked up to a callback function."
+msgstr ""
+"ÎÎÎÏ ÎÎÎÎÎÎÎÏ ÎÎ ÏÎ ÏÎÎÎ ÎÏÎÎÏÎÏÎÏ ÏÏÎÎÎÎÎÎÎ ÏÎ ÎÎÎ ÏÏÎÎÏÏÎÏÎ ÎÏÎÎÎÎÎÎÏÎÏ"
+
+#: C/dialog.vala.page:30(link) C/dialog.js.page:30(link)
+msgid "Gtk.Dialog"
+msgstr "Gtk.Dialog"
+
+#: C/dialog.vala.page:31(link)
+msgid "Gtk.Dialog.with_buttons"
+msgstr "Gtk.Dialog.with_buttons"
+
+#: C/dialog.vala.page:33(link)
+msgid "get_content_area"
+msgstr "get_content_area"
+
+#: C/dialog.js.page:21(p)
+msgid ""
+"A customizable popup window, which has a content area and an action area. "
+"This example dialog's content area contains a short message, and its action "
+"area contains a button which dismisses the dialog."
+msgstr ""
+"ÎÎÎ ÏÏÎÏÎÏÎÏÏÎÎÎ ÎÎÎÎÏÏÎÎÎÎ ÏÎÏÎÎÏÏÎ, ÏÎÏ ÎÏÎÎ ÎÎÎ ÏÎÏÎÎÏÎ ÏÎÏÎÎÏÎÎÎÎÎÏ ÎÎÎ "
+"ÎÎÎ ÏÎÏÎÎÏÎ ÎÎÎÏÎÎÎÎÏ. ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎÏÎÎÏÎÏ ÏÎÏÎÎÏÎÎÎÎÎÏ ÎÎÎÎÏÎÎÏ "
+"ÏÎÏÎÎÏÎÎ ÎÎÎ ÏÏÎÏÎÎÎ ÎÎÎÏÎÎ ÎÎÎ Î ÏÎÏÎÎÏÎ ÎÎÎÏÎÎÎÎÏ ÏÎÏÎÎÏÎÎ ÎÎÎ ÎÎÏÎÏÎ ÏÎÏ "
+"ÎÏÎÏÏÎÏÏÎÎ ÏÎ ÎÎÎÎÎÎÎ."
+
+#: C/desktop.js.page:15(desc)
+msgid "A desktop file for the hello world application"
+msgstr "ÎÎÎ ÎÏÏÎÎÎ ÎÏÎÏÎÎÎÎÎÏ ÎÏÎÎÏÎÎÏ ÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ hello world"
+
+#: C/desktop.js.page:18(title)
+msgid "helloWorld.desktop"
+msgstr "helloWorld.desktop"
+
+#: C/desktop.js.page:19(p)
+msgid ""
+"Running applications from the Terminal is useful at the beginning of the "
+"application making process. To have a fully working <link href=\"http://";
+"library.gnome.org/admin/system-admin-guide/stable/mimetypes-9.html.en"
+"\">application integration</link> in GNOME 3 requires a desktop launcher. "
+"For this you need to create a <file>.desktop</file> file. The .desktop file "
+"describes the application name, the used icon and various integration bits. "
+"A deeper insight to <file>.desktop</file> file can be found <link href="
+"\"http://developer.gnome.org/desktop-entry-spec/\";>here</link>."
+msgstr ""
+"ÎÏÎÏÎÎÏÎÏ ÎÏÎÏÎÎÎÎÏ ÎÏÏ ÏÎÎ ÏÎÏÎÎÏÎÎÏ ÎÎÎÎÎ ÏÏÎÏÎÎÎ ÏÏÎÎ ÎÏÏÎ ÏÎÏ ÎÎÎÏÎÎÏÎÎÏ "
+"ÎÎÏÎÏÎÎÏÎÏ ÏÎÏ ÎÏÎÏÎÎÎÎÏ. ÎÎÎ ÎÎ ÎÏÎÏÎ ÎÎÎ ÏÎÎÏÏÏ ÎÎÎÏÎÏÏÎÎÎÎ <link "
+"href=\"http://library.gnome.org/admin/system-admin-";
+"guide/stable/mimetypes-9.html.en\">ÎÎÎÎÎÎÏÏÎÎÎÎ ÎÏÎÏÎÎÎÎ</link> ÏÏÎ GNOME 3 "
+"ÎÏÎÎÏÎÎÏÎÎ ÎÎÎÏ ÎÎÎÎÎÎÏÎÏ ÎÏÎÏÎÎÎÎÎ ÎÏÎÎÏÎÎÏ. ÎÎÎ ÎÏÏÏ ÏÏÎÎÎÎÎÏÎÎ ÎÎ "
+"ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎ ÎÏÏÎÎÎ <file>.desktop</file>. ÎÎ ÎÏÏÎÎÎ .desktop "
+"ÏÎÏÎÎÏÎÏÎÎ ÏÎ ÏÎÎÎÎ ÏÎÏ ÎÏÎÏÎÎÎÎÏ, ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎÎÎ ÎÎÎÎÎÎÎÎÎ ÎÎÎ ÏÎÎÎÎÎÎ "
+"ÎÏÎÎÎÎÎ ÎÎÎÎÎÎÏÏÏÎÏ. ÎÎÎ ÎÎÎÏÏÎÏÎ ÎÎÏÎÎ ÏÏÎ ÎÏÏÎÎÎ <file>.desktop</file> "
+"ÎÏÎÏÎÎ ÎÎ ÎÏÎÎÎÎ <link href=\"http://developer.gnome.org/desktop-entry-";
+"spec/\">ÎÎÏ</link>."
+
+#: C/desktop.js.page:20(p)
+msgid ""
+"The example shows you the minimum requirements for a <code>.desktop</code> "
+"file."
+msgstr ""
+"ÎÎ ÏÎÏÎÎÎÎÎÎÎ ÎÎÏÎÎÎÎÎÎ ÏÎÏ ÎÎÎÏÎÏÏÎÏ ÎÏÎÎÏÎÏÎÎÏ ÎÎÎ ÎÎÎ ÎÏÏÎÎÎ "
+"<code>.desktop</code>."
+
+#: C/desktop.js.page:33(p)
+msgid "Now let's go through some parts of the <code>.desktop</code> file."
+msgstr "ÎÏÏÎ, ÎÏ ÎÎÎÏÎÏÎÏÎÎ ÎÎÏÎÎÎ ÎÎÏÎ ÏÎÏ ÎÏÏÎÎÎÏ <code>.desktop</code>."
+
+#: C/desktop.js.page:35(p)
+#| msgid "Run the application"
+msgid "Line 4: Name of the application"
+msgstr "ÎÏÎÎÎÎ 4: ÏÎÎÎÎ ÏÎÏ ÎÏÎÏÎÎÎÎÏ"
+
+#: C/desktop.js.page:36(p)
+msgid "Line 5: Specifies a short description of the item"
+msgstr "ÎÏÎÎÎÎ 5: ÎÏÎÎÎÎ ÎÎÎ ÏÏÎÏÎÎÎ ÏÎÏÎÎÏÎÏÎ ÏÎÏ ÏÏÎÎÏÎÎÎÏ"
+
+#: C/desktop.js.page:37(p)
+msgid ""
+"Line 6: Specifies a command to execute when you choose the item from the "
+"menu. In this example exec just tells where to find the <code>helloworld.js</"
+"code> file and the file takes care of the rest."
+msgstr ""
+"ÎÏÎÎÎÎ 6: ÎÏÎÎÎÎ ÎÎÎ ÎÎÏÎÎÎ ÎÎÎ ÎÎÏÎÎÎÏÎ ÏÏÎÎ ÎÏÎÎÎÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ ÎÏÏ ÏÎ "
+"ÎÎÎÎÏ. ÎÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎ exec ÎÏÎÎ ÎÎÎÎ ÏÎÏ ÎÎ ÎÏÎÎÏÎ ÏÎ ÎÏÏÎÎÎ "
+"<code>helloworld.js</code> ÎÎÎ ÏÎ ÎÏÏÎÎÎ ÏÏÎÎÏÎÎÎÎ ÎÎÎ ÏÎ ÏÏÏÎÎÎÏÎ."
+
+#: C/desktop.js.page:38(p)
+msgid ""
+"Line 8: Specifies whether the command in the Exec key runs in a terminal "
+"window."
+msgstr ""
+"ÎÏÎÎÎÎ 8: ÎÏÎÎÎÎ ÎÎÎ Î ÎÎÏÎÎÎ ÏÏÎ ÎÎÎÎÎÎ Exec ÏÏÎÏÎÎ ÏÎ ÎÎÎ ÏÎÏÎÎÏÏÎ "
+"ÏÎÏÎÎÏÎÎÎÏ."
+
+#: C/desktop.js.page:40(p)
+msgid ""
+"If you want your <code>.desktop</code> file to exist as a part of the "
+"system, copy your <code>.desktop</code> file to this directory: ~/.local/"
+"share/applications"
+msgstr ""
+"ÎÎÎ ÎÎÎÎÏÎ ÏÎ ÎÏÏÎÎÎ ÏÎÏ <code>.desktop</code> ÎÎ ÏÏÎÏÏÎÎ ÏÏ ÏÎÎÎÎ ÏÎÏ "
+"ÏÏÏÏÎÎÎÏÎÏ, ÎÎÏÎÎÏÎÏÏÎ ÏÎ ÎÏÏÎÎÎ ÏÎÏ <code>.desktop</code> ÏÎ ÎÏÏÏÎ ÏÎÎ "
+"ÎÎÏÎÎÎÎÎ: ~/.local/share/applications"
+
+#: C/desktop.js.page:41(p)
+msgid ""
+"To put your application to the right category you need to add the necessary "
+"categories to the Categories line. More information on the different "
+"categories can be found in the <link href=\"http://standards.freedesktop.org/";
+"menu-spec/latest/apa.html\">menu spec</link>."
+msgstr ""
+"ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÏ ÏÏÎ ÏÏÏÏÎ ÎÎÏÎÎÎÏÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ "
+"ÏÎÏ ÎÏÎÏÎÎÏÎÏÎÏ ÎÎÏÎÎÎÏÎÎÏ ÏÏÎ ÎÏÎÎÎÎ ÎÎÏÎÎÎÏÎÏÎ. ÎÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ "
+"ÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏÎÎÎÏ ÎÎÏÎÎÎÏÎÎÏ ÎÏÎÏÎÏÎ ÎÎ ÎÏÎÎÎÏÎ ÏÏÎ <link "
+"href=\"http://standards.freedesktop.org/menu-";
+"spec/latest/apa.html\">ÏÏÎÎÎÎÎÏÎÏÎÏ ÎÎÎÎÏ</link>."
+
+#: C/desktop.js.page:42(p)
+msgid ""
+"In this example I used an existing icon. For a custom icon you need to have "
+"a .svg file of your icon, store it to /usr/share/icons/hicolor/scalable/"
+"apps. Write the name of your icon file to the .desktop file, on line 7. More "
+"information on icons in: <link href=\"http://library.gnome.org/admin/system-";
+"admin-guide/stable/themes-11.html.en\"> Installing Icons for Themes </link>, "
+"<link href=\"https://live.gnome.org/GnomeGoals/AppIcon\";>Installing Icons "
+"for Themes</link> and <link href=\"http://freedesktop.org/wiki/";
+"Specifications/icon-theme-spec\">on freedesktop.org: Specifications/icon-"
+"theme-spec</link>."
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎÎ ÎÎÎ ÏÏÎÏÏÎÎ ÎÎÎÎÎÎÎÎÎ. ÎÎÎ ÎÎÎ "
+"ÏÏÎÏÎÏÎÎÏÎÎÎÎ ÎÎÎÎÎÎÎÎÎ ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÏÎÏÎ ÎÎÎ ÎÏÏÎÎÎ .svg ÏÎÏ ÎÎÎÎÎÎÎÎÎÏ "
+"ÏÎÏ, ÎÏÎÎÎÎÎÏÏÏÎ ÏÎ ÏÏÎ /usr/share/icons/hicolor/scalable/apps. ÎÏÎÏÏÎ ÏÎ "
+"ÏÎÎÎÎ ÏÎÏ ÎÏÏÎÎÎÏ ÏÎÏ ÎÎÎÎÎÎÎÎÎÏ ÏÎÏ ÏÏÎ ÎÏÏÎÎÎ .desktop, ÏÏÎ ÎÏÎÎÎÎ 7. "
+"ÎÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÎÎÎ ÎÎÎÎÎÎÎÎÎ ÏÏÎ: <link "
+"href=\"http://library.gnome.org/admin/system-admin-";
+"guide/stable/themes-11.html.en\">ÎÎÎÎÏÎÏÏÎÏÎ ÎÎÎÎÎÎÎÎÏÎ ÎÎÎ ÎÎÎÎÏÎ</link>, "
+"<link href=\"https://live.gnome.org/GnomeGoals/AppIcon\";>ÎÎÎÎÏÎÏÏÎÏÎ "
+"ÎÎÎÎÎÎÎÎÏÎ ÎÎÎ ÎÎÎÎÏÎ</link> ÎÎÎ <link "
+"href=\"http://freedesktop.org/wiki/Specifications/icon-theme-spec\";>on "
+"freedesktop.org: Specifications/icon-theme-spec</link>."
+
+#: C/desktop.js.page:43(p)
+msgid ""
+"After you have finished writing the .desktop file you must change it's "
+"permissions to allow executing file as program. To do that, go to the folder "
+"containing the .desktop file. Right click the .desktop file, choose "
+"properties and tab permissions and place a check on the box after Execute:"
+msgstr ""
+"ÎÏÎÏ ÏÎÎÎÎÏÏÎÏÎ ÏÎ ÎÏÎÏÎÎÎ ÏÎÏ ÎÏÏÎÎÎÏ .desktop ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎ "
+"ÎÎÎÎÎÏÎÎÏÎ ÏÎÏ ÎÎÎ ÎÎ ÎÏÎÏÏÎÏÎÎ Î ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÏÎÎÎÏ ÏÏ ÏÏÎÎÏÎÎÎÎÏÎÏ. ÎÎÎ "
+"ÎÎ ÏÎ ÎÎÎÎÏÎ, ÏÎÎÎÎÎÎÏÎ ÏÏÎ ÏÎÎÎÎÎ ÏÎÏ ÏÎÏÎÎÏÎÎ ÏÎ ÎÏÏÎÎÎ .desktop. ÎÎÎÎ "
+"ÎÎÎÎ ÏÏÎ ÎÏÏÎÎÎ .desktop, ÎÏÎÎÎÎÎ ÎÎÎÎÏÎÏÏÎ ÎÎÎ ÎÎÏÏÎÎÎÏ ÎÎÎÎÎÏÎÎÏÏÎ ÎÎÎ "
+"ÏÎÎÎÎÏÏÏÎ ÏÎ ÏÎÎÎÏÎÎ ÎÎÏÎ ÏÎ ÎÎÏÎÎÎÏÎ:"
+
+#: C/cpp.page:6(title)
+msgid "C++"
+msgstr "C++"
+
+#: C/cpp.page:15(title)
+msgid "Platform demos in C++"
+msgstr "ÎÎÏÎÏÏÎÎÏÎÎÏ ÏÎÎÏÏÏÏÎÎÏ ÏÎ C++"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/combobox.vala.page:20(None)
+msgid "@@image: 'media/combobox.png'; md5=ab9e91bc1a58fe866cb00dd52159251d"
+msgstr "@@image: 'media/combobox.png'Â md5=ab9e91bc1a58fe866cb00dd52159251d"
+
+#: C/combobox.vala.page:16(desc)
+msgid "A widget used to choose from a list of items"
+msgstr ""
+"ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÎ ÎÏÎÎÎÎÎ ÎÏÏ ÎÎÎ ÎÎÏÏÎ ÏÏÎÎÏÎÎÏÎ"
+
+#: C/combobox.vala.page:19(title)
+msgid "ComboBox"
+msgstr "ComboBox"
+
+#: C/combobox.vala.page:21(p)
+msgid "This ComboBox prints to the terminal when you change your selection."
+msgstr "ÎÏÏÏ ÏÎ ComboBox ÏÏÏÏÎÎÎ ÏÏÎÎ ÏÎÏÎÎÏÎÎÏ ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎÎ ÏÎÏ."
+
+#: C/combobox.vala.page:29(link)
+msgid "Gtk.ComboBox"
+msgstr "Gtk.ComboBox"
+
+#: C/combobox.vala.page:30(link)
+msgid "Gtk.CellRendererText"
+msgstr "Gtk.CellRendererText"
+
+#: C/combobox.vala.page:31(link)
+msgid "set_attributes"
+msgstr "set_attributes"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/checkbutton.vala.page:20(None) C/checkbutton.py.page:20(None)
+#: C/checkbutton.c.page:20(None)
+msgid "@@image: 'media/checkbutton.png'; md5=7921a6812c87dd2b3781f4fad241e858"
+msgstr "@@image: 'media/checkbutton.png'Â md5=7921a6812c87dd2b3781f4fad241e858"
+
+#: C/checkbutton.vala.page:16(desc)
+msgid "Create widgets with a disrete toggle button"
+msgstr "ÎÎÎÎÎÏÏÎÎÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ ÎÎ ÎÎÎ ÎÎÎÎÏÎÏÏ ÎÎÏÎÏÎ ÎÎÎÎÎÎÎÎÏ"
+
+#: C/checkbutton.vala.page:19(title) C/checkbutton.py.page:19(title)
+#: C/checkbutton.c.page:19(title)
+msgid "CheckButton"
+msgstr "CheckButton"
+
+#: C/checkbutton.vala.page:21(p) C/checkbutton.py.page:21(p)
+#: C/checkbutton.c.page:21(p)
+msgid "This CheckButton toggles the title."
+msgstr "ÎÏÏÏ ÏÎ CheckButton ÎÎÎÎÎÎÏÏÎÎ ÏÎÎ ÏÎÏÎÎ."
+
+#: C/checkbutton.vala.page:28(link)
+msgid "Gtk.CheckButton"
+msgstr "Gtk.CheckButton"
+
+#: C/checkbutton.py.page:16(desc)
+msgid "A toggle button in a window"
+msgstr "ÎÎÎ ÎÎÏÎÏÎ ÎÎÎÎÎÎÎÎÏ ÏÎ ÏÎÏÎÎÏÏÎ"
+
+#: C/checkbutton.py.page:31(link) C/checkbutton.c.page:28(link)
+msgid "GtkCheckButton"
+msgstr "GtkCheckButton"
+
+#: C/checkbutton.c.page:12(email)
+msgid "tiffany antpoolski gmail com"
+msgstr "tiffany antpoolski gmail com"
+
+#: C/checkbutton.c.page:16(desc)
+msgid "Create widgets with a discrete ToggleButton"
+msgstr "ÎÎÎÎÎÏÏÎÎÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ ÎÎ ÎÎÎ ÎÎÎÎÏÎÏÏ ToggleButton"
+
+#: C/c.page:6(title)
+msgid "C"
+msgstr "C"
+
+#: C/c.page:15(title)
+msgid "Tutorials, code samples, and plaform demos in C"
+msgstr "ÎÎÎÎÎÎÏÎ, ÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ ÎÎÎ ÏÎÏÎÏÏÎÎÏÎÎÏ ÏÎÎÏÏÏÏÎÎÏ ÏÏÎ C"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/button.vala.page:21(None) C/button.py.page:21(None)
+#: C/button.js.page:20(None)
+#| msgid ""
+#| "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+msgid "@@image: 'media/button.png'; md5=8d69efbb3a0d3e043af6139b6492171c"
+msgstr "@@image: 'media/button.png'Â md5=8d69efbb3a0d3e043af6139b6492171c"
+
+#: C/button.vala.page:16(desc) C/button.py.page:16(desc)
+msgid "A button widget which emits a signal when clicked"
+msgstr "ÎÎÎ ÎÎÏÎÏÎ ÎÏÎÏÎÎÎÏ ÏÏÏÏÎÏÎÎÎÏ ÏÎÏ ÎÎÏÎÎÏÎÎ ÏÎÎÎ ÏÏÎÎ ÏÎÏÎÎÎÎ"
+
+#: C/button.vala.page:19(title) C/button.py.page:19(title)
+msgid "Button widget"
+msgstr "ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÎÏÎÏÎÎÏ"
+
+#: C/button.vala.page:22(p) C/button.py.page:22(p)
+msgid "A button widget connected to a simple callback function."
+msgstr ""
+"ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÎÏÎÏÎÎÏ ÏÏÎÎÎÎÎÎÎ ÎÎ ÎÎÎ ÎÏÎÎ ÏÏÎÎÏÏÎÏÎ ÎÏÎÎÎÎÎÎÏÎÏ."
+
+#: C/button.vala.page:26(p)
+msgid ""
+"In this sample we used the following: <link xref=\"GtkApplicationWindow.vala"
+"\">Gtk.ApplicationWindow</link>, <link href=\"http://www.valadoc.org/#!";
+"api=gtk+-2.0/Gtk.Button\">Gtk.Button</link>"
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÏÎÏÎÎÎÏÏ: <link "
+"xref=\"GtkApplicationWindow.vala\">Gtk.ApplicationWindow</link>, <link "
+"href=\"http://www.valadoc.org/#!api=gtk+-2.0/Gtk.Button\";>Gtk.Button</link>"
+
+#: C/button.js.page:16(desc)
+msgid "A button which can be connected to other widgets"
+msgstr "ÎÎÎ ÎÎÏÎÏÎ ÏÎÏ ÎÏÎÏÎÎ ÎÎ ÏÏÎÎÎÎÎÎ ÎÎ ÎÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ"
+
+#: C/button.js.page:19(title)
+msgid "Button"
+msgstr "ÎÎÏÎÏÎ"
+
+#: C/button.js.page:21(p)
+msgid "A button widget that changes its label when you click it."
+msgstr ""
+"ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÎÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÎÎÎ ÏÎÎ ÎÏÎÎÎÏÎ ÏÎÏ ÏÏÎÎ ÏÎ ÏÎÏÎÏÎ."
+
+#: C/bug-filing.page:10(email)
+msgid "tiffany antopolski com"
+msgstr "tiffany antopolski com"
+
+#: C/bug-filing.page:18(title)
+msgid "Help make <app>GNOME Developer Tutorials</app> better"
+msgstr "ÎÎÎÎÎÏÏÎ ÎÎ ÎÎÎÎÏÎ ÏÎ <app>ÎÎÎÎÎÎÏÎ ÎÎÎÏÏÏÎÎÏ ÏÎÏ GNOME</app> ÎÎÎÏÏÎÏÎ"
+
+#: C/bug-filing.page:21(title)
+msgid "Report a bug or suggest an improvement"
+msgstr "ÎÎÎÏÎÏÎ ÏÏÎÎÎÎÏÎÏ Î ÏÏÏÏÎÏÎ ÎÎÎÏÎÏÏÎÏ"
+
+#: C/bug-filing.page:22(p)
+msgid ""
+"<app>GNOME Developer Tutorials</app> are maintained by a volunteer "
+"community. You are welcome to participate. If you notice a problem you can "
+"file a <em>bug report</em>. To file a bug, go to <link href=\"https://";
+"bugzilla.gnome.org/\"/>."
+msgstr ""
+"ÎÎ <app>ÎÎÎÎÎÎÏÎ ÎÎÎÏÏÏÎÎÏ ÏÎÏ GNOME</app> ÏÏÎÏÎÏÎÏÎÏÎÎ ÎÏÏ ÎÎÎ ÎÎÎÎÎÎÏÎÎÎ "
+"ÎÎÎÎÏÏÎÏÎ. ÎÎÏÎÏÏÎ ÎÎÎÎÎÎÏÎÏÎÎÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÏÎÏÎ. ÎÎÎ ÏÎÏÎÏÎÏÎÏÎÏÎ ÎÎÎ "
+"ÏÏÏÎÎÎÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÎÎÎÏÎ ÎÎÎ <em>ÎÎÎÏÎÏÎ ÏÏÎÎÎÎÏÎÏ</em>. ÎÎÎ ÏÏÎÎÎÎÎ "
+"ÏÏÎÎÎÎÏÎÏ ÏÎÎÎÎÎÎÏÎ ÏÏÎ <link href=\"https://bugzilla.gnome.org/\"/>."
+
+#: C/bug-filing.page:25(p)
+msgid ""
+"This is a bug tracking system where users and developers can file details "
+"about bugs, crashes and request enhancements."
+msgstr ""
+"ÎÏÏÏ ÎÎÎÎÎ ÎÎÎ ÏÏÏÏÎÎÎ ÎÎÎÏÎÎÏÏÎÏ ÏÏÎÎÎÎÏÏÎ ÏÏÎÏ ÏÏÎÏÏÎÏ ÎÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏÏÎÏ "
+"ÎÏÎÏÎÏÎ ÎÎ ÎÏÏÎÎÎÎÎÏÎÏÎ ÎÎÏÏÎÎÎÏÎÎÎÏ ÎÎÎ ÏÏÎÎÎÎÏÎ, ÎÎÏÎÏÏÎÏÏÎÎÏ ÎÎÎ "
+"ÎÎÏÎÎÎÏÎ ÎÎÎÏÎÏÏÎÏÎ."
+
+#: C/bug-filing.page:28(p)
+msgid ""
+"To participate you need an account which will give you the ability to gain "
+"access, file bugs, and make comments. Also, you need to register so you can "
+"receive updates by e-mail about the status of your bug. If you don't already "
+"have an account, just click on the <gui>New Account</gui> link to create one."
+msgstr ""
+"ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÏÎÏÎ ÏÏÎÎÎÎÏÏÎÏÏÎ ÎÎÎÎ ÎÎÎÎÏÎÎÏÎÏ ÏÎÏ ÎÎ ÏÎÏ ÎÏÏÎÎ ÏÎ "
+"ÎÏÎÎÏÏÏÎÏÎ ÎÎ ÎÏÎÎÏÎÏÎÏÎ ÏÏÏÏÎÎÏÎ ÏÎ ÎÏÏÎÎÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÏÎ. "
+"ÎÏÎÏÎÏ, ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÎÏÎÏÏÏÎÎÎÎÏÎ ÎÏÏÎ ÏÏÏÎ ÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÏÏÏÎÏÏÎ "
+"ÎÎÎÎÎÏÏÏÎÎÏ ÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÏÎÎ ÎÎÏÎÏÏÎÏÎ ÏÎÏ ÏÏÎÎÎÎÏÏÏ ÏÎÏ. ÎÎÎ ÎÎÎ ÎÏÎÏÎ "
+"ÎÎÎ ÎÎÎ ÎÎÎÎÏÎÎÏÎÏ, ÏÎÏÎÏÏÎ ÎÏÎÎ ÏÏÎ ÏÏÎÎÎÏÎÎ <gui>ÎÎÎÏ ÎÎÎÎÏÎÎÏÎÏÏ</gui> "
+"ÎÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎÎ."
+
+#: C/bug-filing.page:31(p)
+msgid ""
+"Once you have an account, log in, click on <guiseq><gui>File a Bug</"
+"gui><gui>All</gui><gui>gnome-devel-docs</gui></guiseq>. Before reporting a "
+"bug, please read the <link href=\"https://bugzilla.gnome.org/page.cgi?id=bug-";
+"writing.html\">bug writing guidelines</link>, and please <link href="
+"\"https://bugzilla.gnome.org/browse.cgi?product=gnome-games\";>browse</link> "
+"for the bug to see if it already exists."
+msgstr ""
+"ÎÏÎÎÏ ÎÏÎÎÏÎÏÎÏÎ ÎÎÎÎ ÎÎÎÎÏÎÎÏÎÏ, ÎÎÎÎ ÏÏÎ <guiseq><gui>ÎÏÎÏÏÎÎÎ "
+"ÏÏÎÎÎÎÏÎÏ</gui><gui>ÏÎÎ</gui><gui>gnome-devel-docs</gui></guiseq>. ÎÏÎÎ ÏÎÎ "
+"ÎÎÎÏÎÏÎ ÏÏÎÎÎÎÏÎÏ, ÏÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎ ÏÎ <link "
+"href=\"https://bugzilla.gnome.org/page.cgi?id=bug-writing.html\";>ÎÏÎÎÎÎÏ "
+"ÎÎÎÎÎÏÎ ÎÎÎ ÏÏÎÎÏÎÏÎ ÏÏÎÎÎÎÏÎÏ</link> ÎÎÎ ÏÎÏÎÎÎÎÏ <link "
+"href=\"https://bugzilla.gnome.org/browse.cgi?product=gnome-";
+"games\">ÏÎÏÎÎÎÎÎÎÎÏÎ</link> ÎÎÎ ÎÎ ÎÎÎÏÎ ÎÎ ÎÎÎ ÏÏÎÏÏÎÎ."
+
+#: C/bug-filing.page:35(p)
+msgid ""
+"To file your bug, choose the component <gui>platform-demos</gui> in the "
+"<gui>Component</gui> menu."
+msgstr ""
+"ÎÎÎ ÎÏÎÏÏÎÎÎ ÏÎÏ ÏÏÎÎÎÎÏÏÏ ÏÎÏ, ÎÏÎÎÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ <gui>platform-"
+"demos</gui> ÏÏÎ ÎÎÎÎÏ <gui>ÏÏÎÎÏÎÎÎ</gui>."
+
+#: C/bug-filing.page:38(p)
+msgid ""
+"If you are requesting a new feature, choose <gui>enhancement</gui> in the "
+"<gui>Severity</gui> menu. Fill in the Summary and Description sections and "
+"click <gui>Commit</gui>."
+msgstr ""
+"ÎÎÎ ÎÎÏÎÏÎ ÎÎÎ ÎÎÎ ÏÎÏÎÎÏÎÏÎÏÏÎÎÏ, ÎÏÎÎÎÎÏÎ <gui>ÎÎÎÏÎÏÏÎ</gui> ÏÏÎ ÎÎÎÎÏ "
+"<gui>ÏÎÎÎÏÏÏÎÏÎ</gui>. ÎÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÎÎÏÏÎÏÎÏ ÏÎÏÎÎÎÏÎ ÎÎÎ ÏÎÏÎÎÏÎÏÎ ÎÎÎ "
+"ÎÎÎÎ <gui>ÏÏÎÎÎÎÎ</gui>."
+
+#: C/bug-filing.page:42(p)
+msgid ""
+"Your report will be given an ID number, and its status will be updated as it "
+"is being dealt with. Thanks for helping make <app>GNOME Developer Tutorials</"
+"app> better!"
+msgstr ""
+"ÎÏÎÎ ÎÎÎÏÎÏÎ ÏÎÏ ÎÎ ÎÎÎÎÎ ÎÎÎÏ ÎÏÎÎÎÏÏ ID ÎÎÎ Î ÎÎÏÎÏÏÎÏÎ ÏÎÏ ÎÎ ÎÎÎÎÎÏÏÎÎÎ "
+"ÏÏÎÎ ÎÎ ÎÏÎÎÎÏÎÎÏÏÎÎ. ÎÏÏÎÏÎÏÏÎÏÎÎ ÎÎÎ ÏÎ ÎÎÎÎÎÎÎ ÏÎÏ ÎÎ ÎÎÎÎÏÎÎ ÏÎ "
+"<app>ÎÎÎÎÎÎÏÎ ÎÎÎÏÏÏÎÎÏ ÏÎÏ GNOME</app> ÎÎÎÏÏÎÏÎ!"
+
+#: C/beginner.vala.page:11(desc) C/beginner.py.page:11(desc)
+#: C/beginner.c.page:11(desc)
+msgid ""
+"A beginner's guide to GUI programming using GTK+, including code samples and "
+"practice exercises."
+msgstr ""
+"ÎÎÎÏ ÎÎÎÎÏÏ ÎÏÏÎÏÎÏÎ ÏÏÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÏ GUI ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ GTK+, "
+"ÏÏÎÏÎÏÎÎÎÎÎÎÎÎÎ ÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ ÎÎÎ ÏÏÎÎÏÎÎÎÏ ÎÏÎÎÏÎÎÏ."
+
+#: C/beginner.vala.page:18(title) C/beginner.py.page:18(title)
+#: C/beginner.c.page:19(title)
+msgid "0 Beginner's Tutorials"
+msgstr "0 ÎÎÎÎÎÎÏÎ ÎÏÏÎÏÎÏÎ"
+
+#: C/beginner.vala.page:20(p) C/beginner.py.page:22(p) C/beginner.c.page:21(p)
+msgid ""
+"Although these tutorials are designed for beginners, we can't cover all the "
+"basics. Before attempting to follow these tutorials, you are expected to be "
+"familiar with the following concepts:"
+msgstr ""
+"ÎÎ ÎÎÎ ÎÏÏÎ ÏÎ ÎÎÎÎÎÎÏÎ ÏÏÎÎÎÎÏÏÎÎÎÎ ÎÎÎ ÎÏÏÎÏÎÎÏÏ, ÎÎÎ ÎÏÎÏÎÏÎÎ ÎÎ "
+"ÎÎÎÏÏÎÏÎÎ ÏÎÎ ÏÎ ÎÎÏÎÎÎ. ÎÏÎÎ ÎÎ ÏÏÎÏÏÎÎÎÏÎÏÎ ÎÎ ÏÎÏÎÎÎÎÎÏÎÎÏÎÏÎ ÎÏÏÎ ÏÎ "
+"ÎÎÎÎÎÎÏÎ, ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÎÎÏÎÎÎÏÎ ÎÎ ÏÎÏ ÏÎÏÎÎÎÏÏ ÎÎÎÎÎÎÏ:"
+
+#: C/beginner.vala.page:22(p) C/beginner.py.page:24(p) C/beginner.c.page:23(p)
+msgid "Object oriented programming"
+msgstr "ÎÎÏÎÎÎÎÎÎÎÎÏÏÏÎÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÏÏ"
+
+#: C/beginner.vala.page:23(p)
+#| msgid "Basic knowledge of the python programming language"
+msgid "The Vala programming language:"
+msgstr "Î ÎÎÏÏÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Vala:"
+
+#: C/beginner.vala.page:25(link)
+msgid "The Vala Tutorial"
+msgstr "ÎÎ ÎÎÎÎÎÎ Vala"
+
+#: C/beginner.vala.page:26(link)
+msgid "Sample Vala code"
+msgstr "ÎÎÎÎÎÎ ÎÏÎÎÎÎ Vala"
+
+#: C/beginner.vala.page:31(p) C/beginner.py.page:28(p) C/beginner.c.page:28(p)
+msgid ""
+"By following these tutorials you will learn the basics of GUI programming "
+"using Gtk+."
+msgstr ""
+"ÎÎÏÎÎÎÎÎÏÎÏÎÏÎÏ ÎÏÏÎ ÏÎ ÎÎÎÎÎÎÏÎ ÎÎ ÎÎÎÎÏÎ ÏÎ ÎÎÏÎÎÎ ÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ GUI "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ Gtk+."
+
+#: C/beginner.vala.page:35(title) C/beginner.py.page:32(title)
+#: C/beginner.js.page:22(title) C/beginner.c.page:32(title)
+msgid "Tutorials"
+msgstr "ÎÎÎÎÎÎÏÎ"
+
+#: C/beginner.vala.page:39(title) C/beginner.py.page:36(title)
+#: C/beginner.js.page:26(title) C/beginner.c.page:36(title)
+msgid "Code samples"
+msgstr "ÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎ"
+
+#: C/beginner.vala.page:40(p) C/beginner.py.page:38(p)
+#: C/beginner.js.page:27(p) C/beginner.c.page:37(p)
+msgid "To run the code samples:"
+msgstr "ÎÎÎ ÎÎÏÎÎÎÏÎ ÏÏÎ ÎÎÎÎÎÎÏÏÎ ÎÏÎÎÎÎ:"
+
+#: C/beginner.vala.page:44(p)
+msgid "Copy and paste the code into <var>filename</var>.vala"
+msgstr "ÎÎÏÎÎÏÎÏÎ ÎÎÎ ÎÏÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎ ÏÏÎ <var>filename</var>.vala"
+
+#: C/beginner.vala.page:45(p) C/beginner.py.page:43(p) C/beginner.c.page:42(p)
+msgid "In the terminal type:"
+msgstr "ÎÏÎÎ ÏÏÏÎ ÏÎÏÎÎÏÎÎÎÏ:"
+
+#: C/beginner.vala.page:46(screen)
+#, no-wrap
+msgid "valac --pkg gtk+-3.0 <var>filename</var>.vala"
+msgstr "valac --pkg gtk+-3.0 <var>filename</var>.vala"
+
+#: C/beginner.vala.page:47(screen) C/beginner.c.page:45(screen)
+#, no-wrap
+msgid "./<var>filename</var>"
+msgstr "./<var>filename</var>"
+
+#: C/beginner.vala.page:51(title) C/beginner.py.page:48(title)
+#: C/beginner.js.page:36(title) C/beginner.c.page:52(title)
+msgid "Windows"
+msgstr "ÎÎÏÎÎÏÏÎ"
+
+#: C/beginner.vala.page:54(title) C/beginner.py.page:51(title)
+#: C/beginner.js.page:38(title) C/beginner.c.page:55(title)
+msgid "Display widgets"
+msgstr "ÎÎÏÎÎÎÏÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ"
+
+#: C/beginner.vala.page:56(title) C/beginner.py.page:53(title)
+#: C/beginner.js.page:40(title) C/beginner.c.page:57(title)
+msgid "Buttons and toggles"
+msgstr "ÎÎÏÎÏÎÎ ÎÎÎ ÎÎÎÎÎÎÎÎÏ"
+
+#: C/beginner.vala.page:58(title) C/beginner.py.page:55(title)
+#: C/beginner.js.page:42(title) C/beginner.c.page:59(title)
+msgid "Numeric and text data entry"
+msgstr "ÎÎÏÎÏÏÏÎÏÎ ÎÎÎÎÎÎÎÏÎ ÎÏÎÎÎÎÏÎÎÏÎ ÎÎÎ ÎÎÎÎÎÎÎÏ"
+
+#: C/beginner.vala.page:60(title) C/beginner.py.page:59(title)
+#: C/beginner.js.page:44(title) C/beginner.c.page:61(title)
+msgid "Menu, combo box and toolbar widgets"
+msgstr "ÎÎÎÎÏ, ÏÏÎÎÎÏÎ ÏÎÎÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÏÎÎÎÎÎÎÎÎÎÎÏ"
+
+#: C/beginner.vala.page:62(title) C/beginner.py.page:61(title)
+#: C/beginner.js.page:46(title) C/beginner.c.page:63(title)
+msgid "TreeView widget"
+msgstr "ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ TreeView"
+
+#: C/beginner.vala.page:64(title) C/beginner.py.page:63(title)
+#: C/beginner.js.page:48(title) C/beginner.c.page:65(title)
+msgid "Selectors"
+msgstr "ÎÏÎÎÎÎÎÎÏ"
+
+#: C/beginner.vala.page:65(title) C/beginner.py.page:64(title)
+#: C/beginner.js.page:49(title) C/beginner.c.page:66(title)
+msgid "File selectors"
+msgstr "ÎÏÎÎÎÎÎÎÏ ÎÏÏÎÎÏÎ"
+
+#: C/beginner.vala.page:67(title) C/beginner.py.page:66(title)
+#: C/beginner.js.page:51(title) C/beginner.c.page:68(title)
+msgid "Font selectors"
+msgstr "ÎÏÎÎÎÎÎÎÏ ÎÏÎÎÎÎÏÎÏÎÎÏÏÎ"
+
+#: C/beginner.vala.page:69(title) C/beginner.py.page:68(title)
+#: C/beginner.js.page:53(title) C/beginner.c.page:70(title)
+msgid "Color Selectors"
+msgstr "ÎÏÎÎÎÎÎÎÏ ÏÏÏÎÎÏÎÏ"
+
+#: C/beginner.vala.page:72(title) C/beginner.py.page:71(title)
+#: C/beginner.js.page:56(title) C/beginner.c.page:73(title)
+msgid "Layout containers"
+msgstr "ÎÎÏÎÎÎÏÎÏ ÎÎÎÏÎÎÎÏ"
+
+#: C/beginner.vala.page:74(title) C/beginner.py.page:73(title)
+#: C/beginner.js.page:58(title) C/beginner.c.page:75(title)
+msgid "Ornaments"
+msgstr "ÎÎÎÎÎÏÎÎÏÎÎÎ"
+
+#: C/beginner.vala.page:76(title) C/beginner.py.page:75(title)
+#: C/beginner.js.page:60(title) C/beginner.c.page:77(title)
+msgid "Scrolling"
+msgstr "ÎÏÎÎÏÎ"
+
+#: C/beginner.vala.page:78(title) C/beginner.py.page:77(title)
+#: C/beginner.js.page:62(title) C/beginner.c.page:79(title)
+msgid "Miscellaneous"
+msgstr "ÎÎÎÏÎÏÎ"
+
+#: C/beginner.vala.page:83(title) C/beginner.py.page:82(title)
+#: C/beginner.js.page:67(title) C/beginner.c.page:84(title)
+msgid "Exercises"
+msgstr "ÎÏÎÎÏÎÎÏ"
+
+#: C/beginner.py.page:20(p)
+msgid ""
+"If you have never programmed before, or are not familiar with the concepts "
+"of object oriented programming, you may need to learn a few basics first. "
+"The book <link href=\"http://learnpythonthehardway.org/book/\";>Learn Python "
+"the Hard Way</link> may be a better place for you to start. Once you master "
+"the basics, be sure to come back and check out these tutorials."
+msgstr ""
+"ÎÎÎ ÎÎÎ ÎÏÎÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎ ÏÎÏÎ ÏÏÎÎ, Î ÎÎÎ ÎÎÏÏÎ ÎÎÎÎÎÎÎÏÎÎÎÎÏ ÎÎ ÏÎÏ "
+"ÎÎÎÎÎÎÏ ÏÎÏ ÎÎÏÎÎÎÎÎÎÎÎÏÏÏÎÏÎÏÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ, ÎÏÏÏ ÏÏÎÎÎÏÏÎÎÏÎ ÎÎ ÎÎÎÎÏÎ "
+"ÎÎÎÎ ÎÎÏÎÎÎ ÏÏÏÏÎ. ÎÎ ÎÎÎÎÎÎ <link "
+"href=\"http://learnpythonthehardway.org/book/\";> ÎÎÎÎÏÎ Python ÎÎ ÏÎ ÎÏÏÎÎÎÎ "
+"ÏÏÏÏÎ</link> ÎÏÏÏ ÎÎÎÎÎ ÎÎÎÏ ÎÎÎÏÏÎÏÎÏ ÏÏÏÏÎÏ ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎÏÎ. ÎÏÎÎÏ "
+"ÎÎÏÎÎÎÎÏÎÏÎ ÏÎ ÎÎÏÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÏÏÏÎÏÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÏÎ ÎÏÏÎ ÏÎ "
+"ÎÎÎÎÎÎÏÎ."
+
+#: C/beginner.py.page:25(p)
+#| msgid "Basic knowledge of the Python programming language"
+msgid "The Python programming language."
+msgstr "Î ÎÎÏÏÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Python."
+
+#: C/beginner.py.page:42(p)
+msgid "Copy and paste the code into <var>filename</var>.py"
+msgstr "ÎÎÏÎÎÏÎÏÎ ÎÎÎ ÎÏÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎ ÏÏÎ <var>filename</var>.py"
+
+#: C/beginner.py.page:44(screen)
+#, no-wrap
+msgid "python <var>filename</var>.py"
+msgstr "python <var>filename</var>.py"
+
+#: C/beginner.py.page:57(title)
+msgid "Multiline text editor"
+msgstr "ÎÏÎÎÎÏÎÎÏÏÎÏ ÎÎÎÎÎÎÎÏ ÏÎÎÎÎÏÎÏÎ ÎÏÎÎÎÏÎ"
+
+#: C/beginner.js.page:15(desc)
+msgid "A complete beginner's guide to GTK+ programming"
+msgstr "ÎÎÎÏ ÏÎÎÏÎÏ ÎÎÎÎÏÏ ÎÏÏÎÏÎÏÎ ÏÏÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÏ GTK+"
+
+#: C/beginner.js.page:18(title)
+msgid "0 Beginner's Tutorials and samples"
+msgstr "0 ÎÎÎÎÎÎÏÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎÏÎ ÎÏÏÎÏÎÏÎ"
+
+#: C/beginner.js.page:19(p)
+msgid ""
+"In these tutorials and samples we use JavaScript and GTK+. These tutorials "
+"and samples expect you to be familiar with the syntax of JavaScript. If "
+"you're not, read <link href=\"http://eloquentjavascript.net/contents.html";
+"\">Eloquent JavaScript</link> or another guide, to learn how to write "
+"JavaScript code."
+msgstr ""
+"ÎÎ ÎÏÏÎ ÏÎ ÎÎÎÎÎÎÏÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ JavaScript ÎÎÎ GTK+. "
+"ÎÏÏÎ ÏÎ ÎÎÎÎÎÎÏÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎÏÎ ÏÎÏÎÎÎÎÎÏÎ ÎÎ ÎÎÏÏÎ ÎÎÎÎÎÎÎÏÎÎÎÎÏ ÎÎ ÏÎ "
+"ÏÏÎÏÎÎÎ ÏÎÏ JavaScript. ÎÎÎ ÏÏÎ, ÎÎÎÎÎÏÏÎ <link "
+"href=\"http://eloquentjavascript.net/contents.html\";>ÎÏÎÎÏÏÏÎ "
+"JavaScript</link> Î ÎÎÎÎÎ ÎÎÎÎÏ, ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÏÏÏ ÎÎ ÎÏÎÏÎÏÎ ÎÏÎÎÎÎ "
+"JavaScript."
+
+#: C/beginner.js.page:31(p)
+msgid "Copy and paste the code into <var>filename</var>.js"
+msgstr "ÎÎÏÎÎÏÎÏÎ ÎÎÎ ÎÏÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎ ÏÏÎ <var>filename</var>.js"
+
+#: C/beginner.js.page:32(p)
+msgid "In the terminal, type:"
+msgstr "ÎÏÎÎ ÏÎÏÎÎÏÎÎÏ, ÏÎÎÎÏÏÎÎÎÎÎÏÏÎ:"
+
+#: C/beginner.js.page:33(screen)
+#, no-wrap
+msgid "gjs <var>filename</var>.js"
+msgstr "gjs <var>filename</var>.js"
+
+#: C/beginner.c.page:24(p)
+#| msgid "Basic knowledge of the python programming language"
+msgid "The C programming language"
+msgstr "Î ÎÎÏÏÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ C"
+
+#: C/beginner.c.page:41(p)
+msgid "Copy and paste the code into <var>filename</var>.c"
+msgstr "ÎÎÏÎÎÏÎÏÎ ÎÎÎ ÎÏÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎ ÏÏÎ <var>filename</var>.c"
+
+#: C/beginner.c.page:43(screen)
+#, no-wrap
+msgid "gcc <var>filename</var>.c `pkg-config --cflags --libs gtk+-3.0` -o <var>filename</var>\n"
+msgstr "gcc <var>filename</var>.c `pkg-config --cflags --libs gtk+-3.0` -o "
+"<var>filename</var>\n"
+
+#: C/beginner.c.page:49(p)
+msgid ""
+"For more information about compiling Gtk+ programs see <link href=\"http://";
+"developer.gnome.org/gtk3/3.4/gtk-compiling.html\">Compiling Gtk+ "
+"Applications on UNIX</link>."
+msgstr ""
+"ÎÎÎ ÏÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏÎÎÎ ÎÎ ÏÎ ÎÎÏÎÎÎÏÏÏÎÏÎ ÏÏÎÎÏÎÎÎÎÏÏÎ GTK+ "
+"ÎÎÎÏÎ <link href=\"http://developer.gnome.org/gtk3/3.4/gtk-";
+"compiling.html\">ÎÎÏÎÎÎÏÏÏÎÎÎÎÏÎÏ ÎÏÎÏÎÎÎÎÏ GTK+ ÏÏÎ UNIX</link>."
+
+#: C/audio-player.vala.page:9(desc)
+msgid "Coming soon..."
+msgstr "ÎÏÏÎÏÎÎ ÏÏÎÏÎÎÎ..."
+
+#: C/audio-player.vala.page:18(title)
+msgid "3 Audio Player"
+msgstr "3 ÎÎÎÏÎÏÎÎÏÎÏÏ ÎÏÎÏ"
+
+#. When image changes, this message will be marked fuzzy or untranslated for you.
+#. It doesn't matter what you translate it to: it's not used at all.
+#: C/aboutdialog.vala.page:26(None) C/aboutdialog.py.page:20(None)
+#: C/aboutdialog.js.page:19(None)
+msgid ""
+"@@image: 'media/aboutdialog_GMenu.png'; md5=a36117a559fa98e25e2f6b3db593639f"
+msgstr ""
+"@@image: 'media/aboutdialog_GMenu.png'Â md5=a36117a559fa98e25e2f6b3db593639f"
+
+#: C/aboutdialog.vala.page:22(desc) C/aboutdialog.js.page:15(desc)
+msgid "Display information about an application"
+msgstr "ÎÎÏÎÎÎÏÎ ÏÎÎÏÎÏÎÏÎÏÎ ÎÎÎ ÎÎÎ ÎÏÎÏÎÎÎÎ"
+
+#: C/aboutdialog.vala.page:25(title) C/aboutdialog.py.page:19(title)
+#: C/aboutdialog.js.page:18(title)
+msgid "AboutDialog"
+msgstr "AboutDialog"
+
+#: C/aboutdialog.vala.page:27(p)
+msgid "An AboutDialog example using Gtk.ApplicationWindow and Menu"
+msgstr ""
+"ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ AboutDialog ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ Gtk.ApplicationWindow ÎÎÎ ÎÎÎÎÏ"
+
+#: C/aboutdialog.vala.page:37(link)
+msgid "set_default_size"
+msgstr "set_default_size"
+
+#: C/aboutdialog.vala.page:38(link)
+msgid "Gtk.Button.with_label"
+msgstr "Gtk.Button.with_label"
+
+#: C/aboutdialog.py.page:16(desc)
+msgid "A window that displays information about an application"
+msgstr "ÎÎÎ ÏÎÏÎÎÏÏÎ ÏÎÏ ÎÎÏÎÎÎÎÎÎ ÏÎÎÏÎÏÎÏÎÎÏ ÎÎÎ ÎÎÎ ÎÏÎÏÎÎÎÎ"
+
+#: C/aboutdialog.py.page:21(p)
+msgid ""
+"An AboutDialog example using Gtk.ApplicationWindow and Menu (the \"about\" "
+"is displayed if \"About\" in the menu is selected)."
+msgstr ""
+"ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ AboutDialog ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ Gtk.ApplicationWindow ÎÎÎ ÎÎÎÎÏ "
+"(ÏÎ \"ÏÏÎÏÎÎÎ\" ÎÎÏÎÎÎÎÎÏÎÎ ÎÎÎ ÏÎ \"ÏÏÎÏÎÎÎ\" ÏÏÎ ÎÎÎÎÏ ÎÏÎÎÎÎÎÎ)."
+
+#: C/aboutdialog.py.page:31(link)
+msgid "GtkAboutDialog"
+msgstr "GtkAboutDialog"
+
+#: C/aboutdialog.js.page:20(p)
+msgid ""
+"A modal dialog window which shows information about an application and its "
+"creators. This one is triggered by clicking \"About\" in the application's "
+"menu, which is normally a good place to put it."
+msgstr ""
+"ÎÎÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÎÏÏÎÎÎÏ ÎÎÎÎÏÎÎÏ ÏÎÏ ÎÎÏÎÎÎÎÎÎ ÏÎÎÏÎÏÎÏÎÎÏ ÎÎÎ ÎÎÎ "
+"ÎÏÎÏÎÎÎÎ ÎÎÎ ÏÎÏÏ ÎÎÎÎÎÏÏÎÎÏÏ ÏÎÏ. ÎÏÏÏ ÏÏÎÎÎÎÎÎÏÎÎ ÎÎ ÎÎÎÎ ÏÏÎ \"ÏÏÎÏÎÎÎ\" "
+"ÏÏÎ ÎÎÎÎÏ ÏÎÏ ÎÏÎÏÎÎÎÎÏ, ÏÎÏ ÎÎÎÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÎ ÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÏÎ."
+
+#: C/aboutdialog.js.page:29(link)
+msgid "Gtk.AboutDialog"
+msgstr "Gtk.AboutDialog"
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2
+#: C/index.page:0(None)
+msgid "translator-credits"
+msgstr "Dimitris Spingos (ÎÎÎÎÏÏÎÏ ÎÏÎÎÎÎÏ) <dmtrs32 gmail com>, 2012"