[gnome-devel-docs] [l10n] Added German translation

[Mario Blättermann <mariobl src gnome org>]

commit 1900f1a875cabf9bbb1f9ed31021cca70acf45a9
Author: Mario Blättermann <mariobl gnome org>
Date:   Thu Mar 31 10:40:35 2011 +0200

    [l10n] Added German translation

 platform-demos/Makefile.am |    2 +-
 platform-demos/de/de.po    | 4118 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 4119 insertions(+), 1 deletions(-)
---
diff --git a/platform-demos/Makefile.am b/platform-demos/Makefile.am
index 7d49345..61a688c 100644
--- a/platform-demos/Makefile.am
+++ b/platform-demos/Makefile.am
@@ -2,7 +2,7 @@ include $(top_srcdir)/gnome-doc-utils.make
 
 DOC_ID = gnome-devel-demos
 
-DOC_LINGUAS = es
+DOC_LINGUAS = de es
 
 demo_sources = \
 	guitar-tuner/guitar-tuner.c \
diff --git a/platform-demos/de/de.po b/platform-demos/de/de.po
new file mode 100644
index 0000000..aee26b4
--- /dev/null
+++ b/platform-demos/de/de.po
@@ -0,0 +1,4118 @@
+# German 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.
+# Mario Blättermann <mariobl freenet de>, 2011.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: gnome-devel-docs master\n"
+"POT-Creation-Date: 2011-03-28 15:40+0000\n"
+"PO-Revision-Date: 2011-03-31 10:37+0100\n"
+"Last-Translator: Mario Blättermann <mariobl freenet de>\n"
+"Language-Team: German <gnome-de gnome org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+#: C/index.page:7(name)
+msgid "GNOME Documentation Team"
+msgstr "GNOME-Dokumentationsteam"
+
+#: C/index.page:8(email) C/record-collection.js.page:13(email)
+#: C/image-viewer.cpp.page:13(email) C/image-viewer.c.page:13(email)
+#: C/guitar-tuner.vala.page:13(email) C/guitar-tuner.py.page:13(email)
+#: C/guitar-tuner.cpp.page:13(email) C/guitar-tuner.c.page:13(email)
+#: C/getting-ready.page:13(email)
+msgid "gnome-doc-list gnome org"
+msgstr "gnome-doc-list gnome org"
+
+#: C/index.page:9(years)
+msgid "2010, 2011"
+msgstr "2010, 2011"
+
+#: C/index.page:12(name) C/message-board.c.page:13(name)
+msgid "Shaun McCance"
+msgstr "Shaun McCance"
+
+#: C/index.page:13(email) C/message-board.c.page:14(email)
+msgid "shaunm gnome org"
+msgstr "shaunm gnome org"
+
+#: C/index.page:14(years) C/message-board.c.page:15(years)
+msgid "2010"
+msgstr "2010"
+
+#: C/index.page:11(credit) C/index.page:16(credit)
+msgid "<placeholder-1/><placeholder-2/><placeholder-3/>i"
+msgstr "<placeholder-1/><placeholder-2/><placeholder-3/>i"
+
+#: C/index.page:17(name) C/record-collection.js.page:16(name)
+#: C/photo-wall.c.page:15(name) C/magic-mirror.vala.page:16(name)
+#: C/image-viewer.js.page:17(name) C/image-viewer.py.page:17(name)
+#: C/image-viewer.cpp.page:16(name) C/image-viewer.c.page:16(name)
+#: C/guitar-tuner.vala.page:16(name) C/guitar-tuner.py.page:16(name)
+#: C/guitar-tuner.cpp.page:16(name) C/guitar-tuner.c.page:16(name)
+msgid "Johannes Schmid"
+msgstr "Johannes Schmid"
+
+#: C/index.page:18(email) C/record-collection.js.page:17(email)
+#: C/photo-wall.c.page:16(email) C/magic-mirror.vala.page:17(email)
+#: C/image-viewer.js.page:18(email) C/image-viewer.py.page:18(email)
+#: C/image-viewer.cpp.page:17(email) C/image-viewer.c.page:17(email)
+#: C/guitar-tuner.vala.page:17(email) C/guitar-tuner.py.page:17(email)
+#: C/guitar-tuner.cpp.page:17(email) C/guitar-tuner.c.page:17(email)
+msgid "jhs gnome org"
+msgstr "jhs gnome org"
+
+#: C/index.page:19(years)
+msgid "2011"
+msgstr "2011"
+
+#: C/index.page:24(title)
+msgid "GNOME Developer Platform Demos"
+msgstr "Demos zur GNOME-Entwicklerplattform"
+
+#: C/index.page:27(title)
+msgid "Getting Ready"
+msgstr ""
+
+#: C/index.page:31(title)
+msgid "C"
+msgstr "C"
+
+#: C/index.page:35(title)
+msgid "C++"
+msgstr "C++"
+
+#: C/index.page:39(title)
+msgid "JavaScript"
+msgstr "JavaScript"
+
+#: C/index.page:43(title)
+msgid "Python"
+msgstr "Python"
+
+#: C/index.page:47(title)
+msgid "Vala"
+msgstr "Vala"
+
+#. 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:62(None)
+msgid ""
+"@@image: 'media/record-collection.png'; md5=2d645997687ed5aacd36aafafc16e072"
+msgstr ""
+"@@image: 'media/record-collection.png'; md5=2d645997687ed5aacd36aafafc16e072"
+
+#: C/record-collection.js.page:8(desc)
+msgid "Create a small database application for ordering your music collection"
+msgstr ""
+"Erstellung einer kleinen Datenbankanwendung zum Verwalten Ihrer Musiksammlung"
+
+#: C/record-collection.js.page:12(name) C/image-viewer.cpp.page:12(name)
+#: C/image-viewer.c.page:12(name) C/guitar-tuner.vala.page:12(name)
+#: C/guitar-tuner.py.page:12(name) C/guitar-tuner.cpp.page:12(name)
+#: C/guitar-tuner.c.page:12(name) C/getting-ready.page:12(name)
+msgid "GNOME Documentation Project"
+msgstr "GNOME-Dokumentationsprojekt"
+
+#: C/record-collection.js.page:21(title)
+msgid "Record Collection"
+msgstr ""
+
+#: C/record-collection.js.page:24(p) C/message-board.c.page:23(p)
+#: C/image-viewer.cpp.page:24(p) C/image-viewer.c.page:24(p)
+msgid "In this tutorial, you will learn:"
+msgstr "In diesem Tutorial lernen Sie, wie:"
+
+#: C/record-collection.js.page:26(p)
+msgid "How to connect to a database using libgda"
+msgstr "eine Verbindung zu einer Datenbank mittels libgda erstellt wird"
+
+#: C/record-collection.js.page:27(p)
+msgid "How to insert and browse records in a database table"
+msgstr ""
+"Datensätze in eine Datenbanktabelle eingefügt werden oder wie die Tabelle "
+"durchsucht werden kann"
+
+#: C/record-collection.js.page:32(title) C/photo-wall.c.page:34(title)
+msgid "Introduction"
+msgstr "Einführung"
+
+#: C/record-collection.js.page:33(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:36(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:39(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 ""
+
+#: C/record-collection.js.page:45(title) C/photo-wall.c.page:44(title)
+#: C/message-board.c.page:40(title) C/magic-mirror.vala.page:42(title)
+#: C/image-viewer.js.page:44(title) C/image-viewer.py.page:43(title)
+#: C/image-viewer.cpp.page:34(title) C/image-viewer.c.page:34(title)
+#: C/guitar-tuner.vala.page:40(title) C/guitar-tuner.py.page:40(title)
+#: C/guitar-tuner.cpp.page:40(title) C/guitar-tuner.c.page:40(title)
+msgid "Create a project in Anjuta"
+msgstr ""
+
+#: C/record-collection.js.page:46(p) C/photo-wall.c.page:45(p)
+#: C/magic-mirror.vala.page:43(p) C/image-viewer.js.page:45(p)
+#: C/image-viewer.py.page:44(p) C/image-viewer.cpp.page:35(p)
+#: C/image-viewer.c.page:35(p) C/guitar-tuner.vala.page:41(p)
+#: C/guitar-tuner.py.page:41(p) C/guitar-tuner.cpp.page:41(p)
+#: C/guitar-tuner.c.page:41(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."
+msgstr ""
+
+#: C/record-collection.js.page:49(p) C/photo-wall.c.page:48(p)
+#: C/magic-mirror.vala.page:46(p) C/image-viewer.js.page:48(p)
+#: C/image-viewer.py.page:47(p) C/image-viewer.cpp.page:38(p)
+#: C/image-viewer.c.page:38(p) C/guitar-tuner.vala.page:44(p)
+#: C/guitar-tuner.py.page:44(p) C/guitar-tuner.cpp.page:44(p)
+#: C/guitar-tuner.c.page:44(p)
+msgid ""
+"Start Anjuta and click <guiseq><gui>File</gui><gui>New</gui><gui>Project</"
+"gui></guiseq> to open the project wizard."
+msgstr ""
+
+#: C/record-collection.js.page:52(p)
+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 ""
+
+#: C/record-collection.js.page:55(p)
+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 ""
+
+#: C/record-collection.js.page:61(title)
+msgid "Program Structure"
+msgstr "Programmstruktur"
+
+#: C/record-collection.js.page:63(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:68(title)
+msgid "Starting the fun"
+msgstr ""
+
+#: C/record-collection.js.page:69(p)
+msgid "Let's start by examining the skeleton of the program:"
+msgstr ""
+
+#: C/record-collection.js.page:95(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 ""
+
+#: C/record-collection.js.page:96(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:97(p)
+msgid "Lines 19â??23: Start the application."
+msgstr ""
+
+#: C/record-collection.js.page:102(title)
+msgid "Designing the application"
+msgstr "Entwurf der Anwendung"
+
+#: C/record-collection.js.page:103(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:154(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:155(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:156(p)
+msgid ""
+"Line 39: Create the widget (<code>TextView</code>) where we will show the "
+"contents of the table."
+msgstr ""
+
+#: C/record-collection.js.page:157(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:162(title)
+msgid "Connecting to and initializing the database"
+msgstr ""
+
+#: C/record-collection.js.page:163(p)
+msgid ""
+"The code which makes the connection to the database is in the "
+"<code>setupDatabase</code> method below:"
+msgstr ""
+
+#: C/record-collection.js.page:180(p)
+msgid ""
+"Lines 2â??3: Create the GDA's <code>Connection</code> object. We must supply to "
+"its constructor some properties:"
+msgstr ""
+
+#: C/record-collection.js.page:183(p)
+msgid ""
+"<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 ""
+
+#: C/record-collection.js.page:186(p)
+msgid ""
+"<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 ""
+
+#: C/record-collection.js.page:190(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 ""
+
+#: C/record-collection.js.page:194(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 ""
+
+#: C/record-collection.js.page:196(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:197(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 ""
+
+#: C/record-collection.js.page:201(p)
+msgid "At this point we have the database set up, and are ready to use it."
+msgstr ""
+
+#: C/record-collection.js.page:205(title)
+msgid "Selecting"
+msgstr "Auswählen"
+
+#: C/record-collection.js.page:206(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 ""
+
+#: C/record-collection.js.page:227(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 ""
+
+#: C/record-collection.js.page:228(p)
+msgid ""
+"Line 3: Create an <code>Iter</code> object, which is used to iterate over the "
+"<code>DataModel</code>'s records."
+msgstr ""
+
+#: C/record-collection.js.page:229(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:231(p)
+msgid "Lines 8â??9: We do two things in each line:"
+msgstr ""
+
+#: C/record-collection.js.page:233(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:234(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:237(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 ""
+
+#: C/record-collection.js.page:238(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:239(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:244(title)
+msgid "Inserting"
+msgstr ""
+
+#: C/record-collection.js.page:245(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:266(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 ""
+
+#: C/record-collection.js.page:270(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 ""
+
+#: C/record-collection.js.page:271(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:272(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 ""
+
+#: C/record-collection.js.page:273(p)
+msgid ""
+"Line 8: Set the name of the table on which the built statement will operate "
+"(it will generate <code>INSERT INTO demo</code>)"
+msgstr ""
+
+#: C/record-collection.js.page:274(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:275(p)
+msgid ""
+"Line 11: Get the dynamically generated <code>Statement</code> object, which "
+"represents a SQL statement."
+msgstr ""
+
+#: C/record-collection.js.page:276(p)
+msgid "Line 12: Finally, execute the SQL statement (<code>INSERT</code>)."
+msgstr ""
+
+#: C/record-collection.js.page:277(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 ""
+
+#: C/record-collection.js.page:278(p)
+msgid ""
+"Line 15: Refresh the view on the screen by doing another <code>SELECT</code>."
+msgstr ""
+
+#: C/record-collection.js.page:280(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 ""
+
+#: C/record-collection.js.page:284(title) C/image-viewer.js.page:305(title)
+#: C/image-viewer.py.page:219(title) C/guitar-tuner.py.page:221(title)
+msgid "Run the application"
+msgstr "Anwendung ausführen"
+
+#: C/record-collection.js.page:285(p)
+msgid ""
+"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 ""
+
+#: C/record-collection.js.page:289(title) C/photo-wall.c.page:377(title)
+#: C/magic-mirror.vala.page:142(title) C/image-viewer.js.page:310(title)
+#: C/image-viewer.py.page:224(title) C/image-viewer.cpp.page:212(title)
+#: C/image-viewer.c.page:220(title) C/guitar-tuner.vala.page:243(title)
+#: C/guitar-tuner.py.page:226(title) C/guitar-tuner.cpp.page:255(title)
+#: C/guitar-tuner.c.page:255(title)
+msgid "Reference Implementation"
+msgstr "Referenz-Implementierung"
+
+#: C/record-collection.js.page:290(p)
+msgid ""
+"If you run into problems with the tutorial, compare your code with this <link "
+"href=\"record-collection/record-collection.js\">reference code</link>."
+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/photo-wall.c.page:76(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:79(None)
+msgid ""
+"@@image: 'media/photo-wall-focused.png'; md5=9f1ceecf3a28c1e468597b093a10cbae"
+msgstr ""
+"@@image: 'media/photo-wall-focused.png'; md5=9f1ceecf3a28c1e468597b093a10cbae"
+
+#: C/photo-wall.c.page:7(desc)
+msgid "A Clutter image viewer"
+msgstr "Ein Clutter-Bildbetrachter"
+
+#: C/photo-wall.c.page:11(name)
+msgid "Chris Kühl"
+msgstr "Chris Kühl"
+
+#: C/photo-wall.c.page:12(email)
+msgid "chrisk openismus com"
+msgstr "chrisk openismus com"
+
+#: C/photo-wall.c.page:20(title)
+msgid "Photo Wall"
+msgstr ""
+
+#: C/photo-wall.c.page:23(p)
+msgid ""
+"For this example we will build a simple image viewer using Clutter. You will "
+"learn:"
+msgstr ""
+
+#: C/photo-wall.c.page:25(p)
+msgid "How to size and position <code>ClutterActor</code>s"
+msgstr ""
+
+#: C/photo-wall.c.page:26(p)
+msgid "How to place an image in a <code>ClutterActor</code>"
+msgstr ""
+
+#: C/photo-wall.c.page:27(p)
+msgid "How to do simple transitions using Clutter's animation framework"
+msgstr ""
+
+#: C/photo-wall.c.page:28(p)
+msgid "How to make <code>ClutterActor</code>s respond to mouse events"
+msgstr ""
+
+#: C/photo-wall.c.page:29(p)
+msgid "How to get file names from a directory"
+msgstr ""
+
+#: C/photo-wall.c.page:35(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:38(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:51(p)
+msgid ""
+"Choose <gui>Gtk+ (simple)</gui> from the <gui>C</gui> tab, click "
+"<gui>Forward</gui>, and fill out your details on the next few pages. Use "
+"<file>photo-wall</file> as project name and directory."
+msgstr ""
+
+#: C/photo-wall.c.page:54(p)
+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 using the interface builder."
+msgstr ""
+
+#: C/photo-wall.c.page:59(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:63(p) C/image-viewer.c.page:49(p)
+#: C/guitar-tuner.c.page:54(p)
+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 ""
+
+#: C/photo-wall.c.page:72(title)
+msgid "A look at Photo Wall"
+msgstr ""
+
+#: C/photo-wall.c.page:73(p)
+msgid "Our image viewer presents the user with a wall of images."
+msgstr ""
+
+#: C/photo-wall.c.page:77(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:83(title)
+msgid "Initial setup"
+msgstr ""
+
+#: C/photo-wall.c.page:84(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:121(title)
+msgid "Jumping into the code"
+msgstr ""
+
+#: C/photo-wall.c.page:122(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:163(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 ""
+
+#: C/photo-wall.c.page:164(p)
+msgid ""
+"Line 7: You must initialize Clutter. If you forget to do this, you will get "
+"very strange errors. Be warned."
+msgstr ""
+
+#: C/photo-wall.c.page:165(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:166(p)
+msgid ""
+"A <code>ClutterStage</code> is the top-level <code>ClutterActor</code> onto "
+"which other <code>ClutterActor</code>s are placed."
+msgstr ""
+
+#: C/photo-wall.c.page:168(p)
+msgid ""
+"Line 12: Here we call our function for getting the image file paths. We'll "
+"look at this in a bit."
+msgstr ""
+
+#: C/photo-wall.c.page:169(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:170(p)
+msgid ""
+"Line 29: Show the stage and <em>all its children</em>, meaning our images."
+msgstr ""
+
+#: C/photo-wall.c.page:171(p)
+msgid "Line 32: Start the Clutter main loop."
+msgstr ""
+
+#: C/photo-wall.c.page:176(title)
+msgid "Setting up our image actors"
+msgstr ""
+
+#: C/photo-wall.c.page:178(p)
+msgid ""
+"In Clutter, an actor is the most basic visual element. Basically, everything "
+"you see is an actor."
+msgstr ""
+
+#: C/photo-wall.c.page:177(p)
+msgid ""
+"<note><placeholder-1/></note> 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 ""
+
+#: C/photo-wall.c.page:196(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:198(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 ""
+
+#: C/photo-wall.c.page:200(p)
+msgid "Line 7: We'll look at this function in a later section."
+msgstr ""
+
+#: C/photo-wall.c.page:202(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:204(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:205(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:211(title)
+msgid "Loading the images"
+msgstr "Laden der Bilder"
+
+#: C/photo-wall.c.page:212(p)
+msgid ""
+"Let's take a short break from Clutter to see how we can get the file names "
+"from our image directory."
+msgstr ""
+
+#: C/photo-wall.c.page:239(p)
+msgid ""
+"Lines 5 and 12: This opens our directory or, if an error occured, returns "
+"after printing an error message."
+msgstr ""
+
+#: C/photo-wall.c.page:240(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:245(title)
+msgid "Set up the actors"
+msgstr ""
+
+#: C/photo-wall.c.page:246(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 ""
+
+#: C/photo-wall.c.page:265(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:268(p)
+msgid ""
+"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 ""
+
+#: C/photo-wall.c.page:271(p)
+msgid "At this point we've got a wall of images that are ready to be viewed."
+msgstr ""
+
+#: C/photo-wall.c.page:275(title)
+msgid "Reacting to the clicks"
+msgstr ""
+
+#: C/photo-wall.c.page:320(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 ""
+
+#: C/photo-wall.c.page:322(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 ""
+
+#: C/photo-wall.c.page:323(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 ""
+
+#: C/photo-wall.c.page:327(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 ""
+
+#: C/photo-wall.c.page:328(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 ""
+
+#: C/photo-wall.c.page:329(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 ""
+
+#: C/photo-wall.c.page:331(p)
+msgid "The address of the <code>ClutterActor</code> to animate"
+msgstr ""
+
+#: C/photo-wall.c.page:332(p)
+msgid ""
+"The animation mode to use. Here we use <code>CLUTTER_LINEAR</code> so that we "
+"have a constant speed for animation."
+msgstr ""
+
+#: C/photo-wall.c.page:333(p)
+msgid ""
+"The duration of the animation in milliseconds. I've chosen 500 ms for this "
+"example."
+msgstr ""
+
+#: C/photo-wall.c.page:334(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 ""
+
+#: C/photo-wall.c.page:335(p)
+msgid ""
+"The last argument must always be <code>NULL</code> to indicate that there are "
+"no more properties to be set."
+msgstr ""
+
+#: C/photo-wall.c.page:337(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 ""
+
+#: C/photo-wall.c.page:338(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 ""
+
+#: C/photo-wall.c.page:340(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 ""
+
+#: C/photo-wall.c.page:341(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 ""
+
+#: C/photo-wall.c.page:342(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 ""
+
+#: C/photo-wall.c.page:343(p)
+msgid ""
+"Line 37: Here we toggle the <code>is_focused</code> flag to the current state."
+msgstr ""
+
+#: C/photo-wall.c.page:344(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 ""
+
+#: C/photo-wall.c.page:346(p)
+msgid ""
+"Remember, however, that to receive events the <code>ClutterActor</code>s must "
+"be set <code>reactive</code>."
+msgstr ""
+
+#: C/photo-wall.c.page:350(p)
+msgid ""
+"The following is the convenience function passed to <code>g_slist_foreach</"
+"code>."
+msgstr ""
+
+#: C/photo-wall.c.page:363(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 ""
+
+#: C/photo-wall.c.page:364(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 ""
+
+#: C/photo-wall.c.page:369(title) C/image-viewer.cpp.page:206(title)
+#: C/image-viewer.c.page:214(title) C/guitar-tuner.vala.page:237(title)
+#: C/guitar-tuner.cpp.page:249(title) C/guitar-tuner.c.page:249(title)
+msgid "Build and run the application"
+msgstr ""
+
+#: C/photo-wall.c.page:370(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 ""
+
+#: C/photo-wall.c.page:372(p)
+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 ""
+
+#: C/photo-wall.c.page:373(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 ""
+
+#: C/photo-wall.c.page:378(p)
+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 ""
+
+#. 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:35(None)
+msgid "@@image: 'media/message-board.ogv'; md5=beb80c4538776dc2cdd26c95abea5027"
+msgstr ""
+"@@image: 'media/message-board.ogv'; md5=beb80c4538776dc2cdd26c95abea5027"
+
+#: C/message-board.c.page:9(desc)
+msgid "A simple program using WebKitGTK+ and the DOM."
+msgstr ""
+
+#: C/message-board.c.page:20(title)
+msgid "Message Board"
+msgstr ""
+
+#: C/message-board.c.page:25(p)
+msgid "How to display a web page with WebKit."
+msgstr ""
+
+#: C/message-board.c.page:26(p)
+msgid ""
+"How to manipulate the contents of a web page using WebKit's DOM functions."
+msgstr ""
+
+#: C/message-board.c.page:29(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/message-board.c.page:42(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 ""
+
+#: C/message-board.c.page:47(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 ""
+
+#: C/message-board.c.page:53(p)
+msgid ""
+"In Anjuta, click <guiseq><gui>File</gui><gui>New</gui><gui>Project</gui></"
+"guiseq> to open the new project assistant."
+msgstr ""
+
+#: C/message-board.c.page:55(p)
+msgid ""
+"Select <gui>GTK+ (simple)</gui> on the <gui>C</gui> tab, and click "
+"<gui>Forward</gui>."
+msgstr ""
+
+#: C/message-board.c.page:57(p)
+msgid ""
+"Fill out your details on the <gui>Basic information</gui> page. Use "
+"<input>message-board</input> for the project name. Click <gui>Forward</gui>."
+msgstr ""
+
+#: C/message-board.c.page:60(p)
+msgid ""
+"Disable the <gui>Use GtkBuilder for user interface</gui> option as this "
+"tutorial builds the user-interface manually."
+msgstr ""
+
+#: C/message-board.c.page:63(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>Forward</gui>. On the <gui>Configure external packages</gui> "
+"page, check <gui>webkitgtk-3.0</gui>."
+msgstr ""
+
+#: C/message-board.c.page:69(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 ""
+
+#: C/message-board.c.page:76(code)
+#, no-wrap
+msgid "#include &lt;webkit/webkit.h&gt;"
+msgstr "#include &lt;webkit/webkit.h&gt;"
+
+#: C/message-board.c.page:78(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 ""
+
+#: C/message-board.c.page:84(p)
+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 ""
+
+#: C/message-board.c.page:90(title)
+msgid "Lay out your window and web view"
+msgstr ""
+
+#: C/message-board.c.page:92(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 ""
+
+#: C/message-board.c.page:132(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 ""
+
+#: C/message-board.c.page:138(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 ""
+
+#: C/message-board.c.page:144(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 ""
+
+#: C/message-board.c.page:151(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 ""
+
+#: C/message-board.c.page:158(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 ""
+
+#: C/message-board.c.page:164(code)
+#, no-wrap
+msgid "WEBKIT_WEB_VIEW (view)"
+msgstr ""
+
+#: C/message-board.c.page:165(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 ""
+
+#: C/message-board.c.page:170(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:171(p)
+msgid "The simplest HTML file you could possibly write."
+msgstr ""
+
+#: C/message-board.c.page:174(code)
+#, no-wrap
+msgid "\"text/html\""
+msgstr "\"text/html\""
+
+#: C/message-board.c.page:175(p)
+msgid ""
+"The MIME type of the content you provided. In this case, you're using plain "
+"HTML."
+msgstr ""
+
+#: C/message-board.c.page:179(code)
+#, no-wrap
+msgid "\"UTF-8\""
+msgstr "\"UTF-8\""
+
+#: C/message-board.c.page:180(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 ""
+
+#: C/message-board.c.page:185(code)
+#, no-wrap
+msgid "NULL"
+msgstr "NULL"
+
+#: C/message-board.c.page:186(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 ""
+
+#: C/message-board.c.page:193(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 ""
+
+#: C/message-board.c.page:201(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 ""
+
+#: C/message-board.c.page:205(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:211(title)
+msgid "Hook up signals"
+msgstr ""
+
+#: C/message-board.c.page:213(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 ""
+
+#: C/message-board.c.page:224(p)
+msgid ""
+"You then have to actually define <code>entry_activate_cb</code>. Define it as "
+"follows, anywhere above <code>create_window</code>:"
+msgstr ""
+
+#: C/message-board.c.page:247(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 ""
+
+#: C/message-board.c.page:253(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 ""
+
+#: C/message-board.c.page:260(cite) C/message-board.c.page:272(cite)
+#: C/message-board.c.page:324(cite) C/message-board.c.page:381(cite)
+#: C/message-board.c.page:389(cite)
+msgid "shaunm"
+msgstr "shaunm"
+
+#: C/message-board.c.page:261(p)
+msgid "FIXME: Is this true? Does query_selector take CSS, CSSish, or what?"
+msgstr ""
+
+#: C/message-board.c.page:264(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 ""
+
+#: C/message-board.c.page:273(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 ""
+
+#: C/message-board.c.page:277(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 ""
+
+#: C/message-board.c.page:284(title)
+msgid "Make it look better with CSS"
+msgstr ""
+
+#: C/message-board.c.page:286(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 ""
+
+#: C/message-board.c.page:293(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 ""
+
+#: C/message-board.c.page:315(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 ""
+
+#: C/message-board.c.page:320(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 ""
+
+#: C/message-board.c.page:324(p)
+msgid "g_base64_encode has bad args"
+msgstr ""
+
+#: C/message-board.c.page:336(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 ""
+
+#: C/message-board.c.page:339(code)
+#, no-wrap
+msgid ""
+"\n"
+"gchar *tmp, *css;\n"
+msgstr ""
+"\n"
+"gchar *tmp, *css;\n"
+
+#: C/message-board.c.page:343(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 ""
+
+#: C/message-board.c.page:350(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 ""
+
+#: C/message-board.c.page:357(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:363(title)
+msgid "Learn more"
+msgstr ""
+
+#: C/message-board.c.page:365(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 ""
+
+#: C/message-board.c.page:371(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 ""
+
+#: C/message-board.c.page:377(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 ""
+
+#: C/message-board.c.page:381(p)
+msgid "Link to method to get HTML from DOM and to GIO APIs."
+msgstr ""
+
+#: C/message-board.c.page:385(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 ""
+
+#: C/message-board.c.page:389(p)
+msgid "Link to strftime or something"
+msgstr ""
+
+#: C/message-board.c.page:392(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 ""
+
+#. 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:39(None)
+msgid "@@image: 'media/magic-mirror.png'; md5=8171faea6ed3b6ddac0da084c29e4e22"
+msgstr "@@image: 'media/magic-mirror.png'; md5=8171faea6ed3b6ddac0da084c29e4e22"
+
+#: C/magic-mirror.vala.page:8(desc)
+msgid "Use your webcam as a mirror using the GStreamer framework and Gtk+"
+msgstr ""
+
+#: C/magic-mirror.vala.page:12(name)
+msgid "Daniel G. Siegel"
+msgstr "Daniel G. Siegel"
+
+#: C/magic-mirror.vala.page:13(email)
+msgid "dgsiegel gnome org"
+msgstr "dgsiegel gnome org"
+
+#: C/magic-mirror.vala.page:21(title)
+msgid "Magic Mirror"
+msgstr ""
+
+#: C/magic-mirror.vala.page:24(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 ""
+
+#: C/magic-mirror.vala.page:25(p)
+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:27(p)
+msgid "Create a GTK+ application"
+msgstr ""
+
+#: C/magic-mirror.vala.page:28(p)
+msgid "Access your webcam using GStreamer and embed the result into a window"
+msgstr ""
+
+#: C/magic-mirror.vala.page:29(p)
+msgid "Grab photos off your webcam"
+msgstr ""
+
+#: C/magic-mirror.vala.page:31(p) C/image-viewer.js.page:33(p)
+#: C/image-viewer.py.page:33(p) C/guitar-tuner.vala.page:30(p)
+#: C/guitar-tuner.py.page:30(p) C/guitar-tuner.cpp.page:30(p)
+#: C/guitar-tuner.c.page:30(p)
+msgid "You'll need the following to be able to follow this tutorial:"
+msgstr ""
+
+#: C/magic-mirror.vala.page:33(p) C/image-viewer.js.page:35(p)
+#: C/image-viewer.py.page:35(p) C/guitar-tuner.vala.page:32(p)
+#: C/guitar-tuner.py.page:32(p) C/guitar-tuner.cpp.page:32(p)
+#: C/guitar-tuner.c.page:32(p)
+msgid "An installed copy of the <link xref=\"getting-ready\">Anjuta IDE</link>"
+msgstr ""
+
+#: C/magic-mirror.vala.page:34(p)
+msgid "Installed copies of GTK, GStreamer, and a Vala compiler"
+msgstr ""
+
+#: C/magic-mirror.vala.page:35(p)
+msgid "Basic knowledge of an object-oriented programming language"
+msgstr ""
+
+#: C/magic-mirror.vala.page:49(p)
+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 ""
+
+#: C/magic-mirror.vala.page:52(p)
+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 ""
+
+#: C/magic-mirror.vala.page:57(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 ""
+
+#: C/magic-mirror.vala.page:61(p)
+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 ""
+
+#: C/magic-mirror.vala.page:70(title) C/image-viewer.cpp.page:60(title)
+#: C/image-viewer.c.page:58(title) C/guitar-tuner.vala.page:63(title)
+#: C/guitar-tuner.cpp.page:63(title) C/guitar-tuner.c.page:63(title)
+msgid "Build the code for the first time"
+msgstr ""
+
+#: C/magic-mirror.vala.page:71(p)
+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:74(p) C/guitar-tuner.vala.page:68(p)
+msgid ""
+"The two <code>using</code> lines import namespaces so we don't have to name "
+"them explicitly."
+msgstr ""
+
+#: C/magic-mirror.vala.page:77(p)
+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 ""
+
+#: C/magic-mirror.vala.page:81(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 ""
+
+#: C/magic-mirror.vala.page:85(p) C/image-viewer.cpp.page:76(p)
+#: C/image-viewer.c.page:77(p) C/guitar-tuner.vala.page:79(p)
+#: C/guitar-tuner.cpp.page:78(p) C/guitar-tuner.c.page:82(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>)."
+msgstr ""
+
+#: C/magic-mirror.vala.page:86(p) C/guitar-tuner.vala.page:80(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 ""
+
+#: C/magic-mirror.vala.page:90(title)
+msgid "Access the webcam video stream with GStreamer"
+msgstr ""
+
+#: C/magic-mirror.vala.page:91(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 ""
+
+#: C/magic-mirror.vala.page:118(p)
+msgid ""
+"First we remove the window we created before because GStreamer will take care "
+"of showing the picture on screen."
+msgstr ""
+
+#: C/magic-mirror.vala.page:122(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 ""
+
+#: C/magic-mirror.vala.page:129(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:133(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 ""
+
+#: C/magic-mirror.vala.page:143(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 ""
+
+#: C/magic-mirror.vala.page:149(title) C/guitar-tuner.vala.page:248(title)
+msgid "Further reading"
+msgstr "Weitere Informationen"
+
+#: C/magic-mirror.vala.page:150(p) C/guitar-tuner.vala.page:249(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 ""
+
+#: C/magic-mirror.vala.page:155(title)
+msgid "Conclusion"
+msgstr ""
+
+#: C/magic-mirror.vala.page:156(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 ""
+
+#. 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.js.page:41(None) C/image-viewer.py.page:40(None)
+#: C/image-viewer.cpp.page:31(None) C/image-viewer.c.page:31(None)
+msgid "@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+msgstr "@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+
+#: C/image-viewer.js.page:9(desc)
+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 ""
+
+#: C/image-viewer.js.page:13(name) C/image-viewer.py.page:13(name)
+msgid "Jonh Wendell"
+msgstr "Jonh Wendell"
+
+#: C/image-viewer.js.page:14(email) C/image-viewer.py.page:14(email)
+msgid "jwendell gnome org"
+msgstr "jwendell gnome org"
+
+#: C/image-viewer.js.page:23(title) C/image-viewer.py.page:23(title)
+#: C/image-viewer.cpp.page:21(title) C/image-viewer.c.page:21(title)
+msgid "Image Viewer"
+msgstr "Bildbetrachter"
+
+#: C/image-viewer.js.page:26(p) C/image-viewer.py.page:26(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 ""
+
+#: C/image-viewer.js.page:28(p)
+msgid "Write a basic GTK user interface in JavaScript"
+msgstr ""
+
+#: C/image-viewer.js.page:29(p) C/image-viewer.py.page:29(p)
+msgid "Deal with events by connecting signals to signal handlers"
+msgstr ""
+
+#: C/image-viewer.js.page:30(p) C/image-viewer.py.page:30(p)
+msgid "Lay out GTK user interfaces using containers"
+msgstr ""
+
+#: C/image-viewer.js.page:31(p) C/image-viewer.py.page:31(p)
+msgid "Load and display image files"
+msgstr ""
+
+#: C/image-viewer.js.page:36(p)
+msgid "An installed copy of the <em>gjs</em> interpreter"
+msgstr ""
+
+#: C/image-viewer.js.page:37(p)
+msgid "Basic knowledge of any object-orientated programming language"
+msgstr ""
+
+#: C/image-viewer.js.page:51(p)
+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 ""
+
+#: C/image-viewer.js.page:54(p)
+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 ""
+
+#: C/image-viewer.js.page:61(title)
+msgid "JavaScript basics: Hello World"
+msgstr ""
+
+#: C/image-viewer.js.page:62(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 ""
+
+#: C/image-viewer.js.page:63(code)
+#, no-wrap
+msgid "print (\"Hello world!\");"
+msgstr "print (\"Hello world!\");"
+
+#: C/image-viewer.js.page:64(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 ""
+
+#: C/image-viewer.js.page:68(title)
+msgid "Classes in JavaScript"
+msgstr "Klassen in JavaScript"
+
+#: C/image-viewer.js.page:69(p)
+msgid "This is the standard way to define a class in JavaScript:"
+msgstr ""
+
+#: C/image-viewer.js.page:92(p)
+msgid ""
+"This defines a class called <code>MyClass</code>. Let's go through each part "
+"of the class definition:"
+msgstr ""
+
+#: C/image-viewer.js.page:95(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 ""
+
+#: C/image-viewer.js.page:98(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 ""
+
+#: C/image-viewer.js.page:101(p)
+msgid ""
+"The first method defined here is called <code>_init</code>, and we specify "
+"that it is a function with no arguments:"
+msgstr ""
+
+#: C/image-viewer.js.page:102(code)
+#, no-wrap
+msgid "_init: function ()"
+msgstr "_init: function ()"
+
+#: C/image-viewer.js.page:103(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 ""
+
+#: C/image-viewer.js.page:106(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 ""
+
+#: C/image-viewer.js.page:109(p)
+msgid ""
+"Note how the class definition (prototype) is arranged; each function "
+"definition is separated by a comma."
+msgstr ""
+
+#: C/image-viewer.js.page:113(p)
+msgid "Now that MyClass has been defined, we can play with it:"
+msgstr ""
+
+#: C/image-viewer.js.page:119(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 ""
+
+#: C/image-viewer.js.page:120(p)
+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 ""
+
+#: C/image-viewer.js.page:125(title) C/image-viewer.py.page:64(title)
+msgid "A first Gtk application"
+msgstr "Eine erste Gtk-Anwendung"
+
+#: C/image-viewer.js.page:126(p)
+msgid "Let's see what a very basic Gtk application looks like in JavaScript:"
+msgstr ""
+
+#: C/image-viewer.js.page:136(p) C/image-viewer.py.page:89(p)
+msgid "Let's take a look at what's happening:"
+msgstr ""
+
+#: C/image-viewer.js.page:139(p) C/image-viewer.py.page:92(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 ""
+
+#: C/image-viewer.js.page:142(p)
+msgid ""
+"<code>Gtk.init</code> initializes the Gtk library; this statement is "
+"mandatory for all Gtk programs."
+msgstr ""
+
+#: C/image-viewer.js.page:145(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 ""
+
+#: C/image-viewer.js.page:146(p)
+msgid ""
+"The next line explicitly shows the window. In Gtk, every widget is hidden by "
+"default."
+msgstr ""
+
+#: C/image-viewer.js.page:147(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 ""
+
+#: C/image-viewer.js.page:150(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 ""
+
+#: C/image-viewer.js.page:155(title)
+msgid "Adding classes"
+msgstr "Hinzufügen von Klassen"
+
+#: C/image-viewer.js.page:156(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 ""
+
+#. FIXME: Throws an error, "JS ERROR: !!!   Unhandled type int32 releasing GArgument" on Ubuntu 10.10
+#: C/image-viewer.js.page:175(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 ""
+
+#: C/image-viewer.js.page:176(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:180(title) C/image-viewer.py.page:113(title)
+msgid "Signals"
+msgstr "Signale"
+
+#: C/image-viewer.js.page:181(p) C/image-viewer.py.page:114(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 ""
+
+#: C/image-viewer.js.page:188(p) C/image-viewer.py.page:121(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 ""
+
+#: C/image-viewer.js.page:189(p)
+msgid "The syntax for connecting any signal to a function is:"
+msgstr ""
+
+#: C/image-viewer.js.page:192(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 ""
+
+#: C/image-viewer.js.page:195(p)
+msgid ""
+"You can simplify the code by making use of an inline function definition:"
+msgstr ""
+
+#: C/image-viewer.js.page:203(title)
+msgid "Closing the window"
+msgstr "SchlieÃ?en des Fensters"
+
+#: C/image-viewer.js.page:204(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 ""
+
+#: C/image-viewer.js.page:205(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 ""
+
+#: C/image-viewer.js.page:206(code)
+#, no-wrap
+msgid "this.window.connect (\"hide\", Gtk.main_quit);"
+msgstr "this.window.connect (\"hide\", Gtk.main_quit);"
+
+#: C/image-viewer.js.page:207(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 ""
+
+#: C/image-viewer.js.page:211(title) C/image-viewer.py.page:125(title)
+msgid "Containers: Laying-out the user interface"
+msgstr ""
+
+#: C/image-viewer.js.page:212(p) C/image-viewer.py.page:126(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 ""
+
+#: C/image-viewer.js.page:213(p) C/image-viewer.py.page:127(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 ""
+
+#: C/image-viewer.js.page:215(p) C/image-viewer.py.page:129(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 ""
+
+#: C/image-viewer.js.page:217(p)
+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 ""
+
+#: C/image-viewer.js.page:221(p)
+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 ""
+
+#: C/image-viewer.js.page:222(p) C/image-viewer.py.page:140(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 ""
+
+#: C/image-viewer.js.page:226(title) C/image-viewer.py.page:144(title)
+msgid "Packing: Adding widgets to the container"
+msgstr "Packen: Hinzufügen von Widgets zum Container"
+
+#: C/image-viewer.js.page:227(p)
+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 ""
+
+#: C/image-viewer.js.page:231(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. 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 ""
+
+#: C/image-viewer.js.page:232(p)
+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 ""
+
+#: C/image-viewer.js.page:233(p) C/image-viewer.py.page:152(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 ""
+
+#: C/image-viewer.js.page:234(p) C/image-viewer.py.page:153(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 ""
+
+#: C/image-viewer.js.page:235(p) C/image-viewer.py.page:154(p)
+msgid "Now insert these two lines, below the two you just added:"
+msgstr ""
+
+#: C/image-viewer.js.page:239(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>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 ""
+
+#: C/image-viewer.js.page:240(p)
+msgid ""
+"Finally, we must change the <code>this.window.show ();</code> line to read:"
+msgstr ""
+
+#: C/image-viewer.js.page:241(code)
+#, no-wrap
+msgid "this.window.show_all ();"
+msgstr "this.window.show_all ();"
+
+#: C/image-viewer.js.page:242(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 ""
+
+#: C/image-viewer.js.page:246(title) C/image-viewer.py.page:163(title)
+msgid ""
+"Loading the image: Connecting to the button's <code>clicked</code> signal"
+msgstr ""
+
+#: C/image-viewer.js.page:247(p)
+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 ""
+
+#: C/image-viewer.js.page:248(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>_openClicked</code>. Put this "
+"code immediately after the <code>var open_button = new Gtk.Button</code> line "
+"where the button was created:"
+msgstr ""
+
+#: C/image-viewer.js.page:251(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 ""
+
+#: C/image-viewer.js.page:252(code)
+#, no-wrap
+msgid "const Lang = imports.lang;"
+msgstr "const Lang = imports.lang;"
+
+#: C/image-viewer.js.page:256(title) C/image-viewer.py.page:174(title)
+msgid "Loading the image: Writing the signal's callback"
+msgstr ""
+
+#: C/image-viewer.js.page:257(p)
+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 ""
+
+#: C/image-viewer.js.page:277(p) C/image-viewer.py.page:191(p)
+#: C/image-viewer.cpp.page:172(p) C/image-viewer.c.page:184(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.js.page:280(p)
+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 ""
+
+#: C/image-viewer.js.page:283(p) C/image-viewer.py.page:197(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 ""
+
+#: C/image-viewer.js.page:284(p) C/image-viewer.py.page:198(p)
+#: C/image-viewer.cpp.page:182(p) C/image-viewer.c.page:196(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 ""
+
+#: C/image-viewer.js.page:287(p) C/image-viewer.py.page:201(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 ""
+
+#: C/image-viewer.js.page:290(p) C/image-viewer.py.page:204(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 ""
+
+#: C/image-viewer.js.page:293(p)
+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 ""
+
+#: C/image-viewer.js.page:295(p) C/image-viewer.py.page:209(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 ""
+
+#: C/image-viewer.js.page:298(p) C/image-viewer.py.page:212(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 ""
+
+#: C/image-viewer.js.page:306(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 JavaScript and Gtk) in not much time at all!"
+msgstr ""
+
+#: C/image-viewer.js.page:311(p)
+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 ""
+
+#: C/image-viewer.js.page:315(title) C/image-viewer.py.page:229(title)
+#: C/image-viewer.cpp.page:217(title) C/image-viewer.c.page:225(title)
+#: C/guitar-tuner.vala.page:254(title) C/guitar-tuner.py.page:231(title)
+#: C/guitar-tuner.cpp.page:268(title) C/guitar-tuner.c.page:260(title)
+msgid "Next steps"
+msgstr "Nächste Schritte"
+
+#: C/image-viewer.js.page:316(p) C/image-viewer.py.page:230(p)
+#: C/image-viewer.cpp.page:218(p) C/image-viewer.c.page:226(p)
+#: C/guitar-tuner.vala.page:255(p) C/guitar-tuner.py.page:232(p)
+#: C/guitar-tuner.cpp.page:269(p) C/guitar-tuner.c.page:261(p)
+msgid "Here are some ideas for how you can extend this simple demonstration:"
+msgstr ""
+
+#: C/image-viewer.js.page:319(p) C/image-viewer.py.page:233(p)
+#: C/image-viewer.cpp.page:221(p) C/image-viewer.c.page:229(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.js.page:322(p) C/image-viewer.py.page:236(p)
+#: C/image-viewer.cpp.page:224(p) C/image-viewer.c.page:232(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.js.page:323(p) C/image-viewer.py.page:237(p)
+#: C/image-viewer.cpp.page:225(p) C/image-viewer.c.page:233(p)
+msgid ""
+"<link href=\"http://www.gegl.org/api.html\";>GEGL</link> provides powerful "
+"image manipulation capabilities."
+msgstr ""
+
+#: C/image-viewer.js.page:326(p) C/image-viewer.py.page:240(p)
+#: C/image-viewer.cpp.page:228(p) C/image-viewer.c.page:236(p)
+msgid ""
+"Allow the user to load images from network shares, scanners, and other more "
+"complicated sources."
+msgstr ""
+
+#: C/image-viewer.js.page:327(p) C/image-viewer.py.page:241(p)
+#: C/image-viewer.cpp.page:229(p) C/image-viewer.c.page:237(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 ""
+
+#: C/image-viewer.py.page:9(desc)
+msgid ""
+"A little bit more than a simple \"Hello world\" application - write an image "
+"viewer in GTK."
+msgstr ""
+
+#: C/image-viewer.py.page:28(p)
+msgid "Write a basic GTK user interface in Python"
+msgstr ""
+
+#: C/image-viewer.py.page:36(p)
+msgid "Basic knowledge of the python programming language"
+msgstr ""
+
+#: C/image-viewer.py.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>image-viewer</file> as project name and directory."
+msgstr ""
+
+#: C/image-viewer.py.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>."
+msgstr ""
+
+#: C/image-viewer.py.page:58(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 ""
+
+#: C/image-viewer.py.page:65(p)
+msgid "Let's see what a very basic Gtk application looks like in Python:"
+msgstr ""
+
+#: C/image-viewer.py.page:95(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 ""
+
+#: C/image-viewer.py.page:100(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 ""
+
+#: C/image-viewer.py.page:104(p)
+msgid "The rest of the file does initialisation for Gtk and displays the GUI."
+msgstr ""
+
+#: C/image-viewer.py.page:108(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 ""
+
+#: C/image-viewer.py.page:131(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 ""
+
+#: C/image-viewer.py.page:139(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 ""
+
+#: C/image-viewer.py.page:145(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 ""
+
+#: C/image-viewer.py.page:149(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 ""
+
+#: C/image-viewer.py.page:151(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 ""
+
+#: C/image-viewer.py.page:159(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 ""
+
+#: C/image-viewer.py.page:164(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 ""
+
+#: C/image-viewer.py.page:165(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 ""
+
+#: C/image-viewer.py.page:169(p)
+msgid ""
+"This will connect the <code>clicked</code> signal to <code>on_open_clicked</"
+"code> method that we will define below."
+msgstr ""
+
+#: C/image-viewer.py.page:175(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 ""
+
+#: C/image-viewer.py.page:194(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 ""
+
+#: C/image-viewer.py.page:207(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 ""
+
+#: C/image-viewer.py.page:220(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 ""
+
+#: C/image-viewer.py.page:225(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 ""
+
+#: C/image-viewer.cpp.page:8(desc)
+msgid "A little bit more than a simple \"Hello world\" GTKmm application."
+msgstr ""
+
+#: C/image-viewer.cpp.page:26(p)
+msgid "Some basic concepts of C++/GObject programming"
+msgstr ""
+
+#: C/image-viewer.cpp.page:27(p)
+msgid "How to write a Gtk application in C++"
+msgstr "Schreiben einer Gtk-Anwendung in C++"
+
+#: C/image-viewer.cpp.page:41(p)
+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 ""
+
+#: C/image-viewer.cpp.page:44(p)
+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 ""
+
+#: C/image-viewer.cpp.page:49(p)
+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 ""
+
+#: C/image-viewer.cpp.page:61(p)
+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/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 ""
+
+#: C/image-viewer.cpp.page:67(p)
+msgid ""
+"The <code>main</code> function creates a new (empty) window and sets the "
+"window title."
+msgstr ""
+
+#: 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 ""
+
+#: C/image-viewer.cpp.page:77(p) C/image-viewer.c.page:78(p)
+#: C/guitar-tuner.cpp.page:79(p) C/guitar-tuner.c.page:83(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 ""
+
+#: C/image-viewer.cpp.page:81(title) C/image-viewer.c.page:82(title)
+msgid "Creating the user interface"
+msgstr "Erstellen der Benutzeroberfläche"
+
+#: 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 ""
+
+#: C/image-viewer.cpp.page:119(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:122(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 ""
+
+#: C/image-viewer.cpp.page:128(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 and "
+"to pass the image as an additional argument to that function. We will define "
+"the <em>callback</em> in the next section."
+msgstr ""
+
+#: C/image-viewer.cpp.page:133(p)
+msgid ""
+"The last step is to show all widgets in the window using <code>show_all()</"
+"code>. This is equivalent to using the <code>show()</code> method on all our "
+"widgets."
+msgstr ""
+
+#: C/image-viewer.cpp.page:141(title) C/image-viewer.c.page:147(title)
+msgid "Showing the image"
+msgstr "Bildanzeige"
+
+#: C/image-viewer.cpp.page:142(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 ""
+
+#: C/image-viewer.cpp.page:174(p)
+msgid ""
+"The argument to the signal is the image object that we passed while "
+"connecting the signal. Sometimes there are other arguments related to the "
+"signal, but <em>clicked</em> doesn't have any."
+msgstr ""
+
+#: C/image-viewer.cpp.page:176(p)
+msgid ""
+"The next interesting line is where the dialog for choosing the file is "
+"created using <code>Gtk::FileChooserDialog</code>. The function takes the "
+"title of the dialog and the type of dialog this should be. In our case, it is "
+"an <em>Open</em> dialog."
+msgstr ""
+
+#: C/image-viewer.cpp.page:181(p)
+msgid ""
+"The next two lines add an <em>Open</em> and a <em>Close</em> button to the "
+"dialog."
+msgstr ""
+
+#: C/image-viewer.cpp.page:183(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 ""
+
+#: C/image-viewer.cpp.page:188(p)
+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 ""
+
+#: C/image-viewer.cpp.page:189(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 ""
+
+#: C/image-viewer.cpp.page:193(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 <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 ""
+
+#: C/image-viewer.cpp.page:195(p)
+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 ""
+
+#: C/image-viewer.cpp.page:199(p)
+msgid ""
+"In the final line of this method, we hide the <gui>Open</gui> dialog because "
+"we don't need it any more. The dialog would be hidden anyway, as it is only a "
+"local variable and is destroyed (and as such hidden) when the scope ends."
+msgstr ""
+
+#: C/image-viewer.cpp.page:207(p) C/image-viewer.c.page:215(p)
+#: C/guitar-tuner.c.page:250(p)
+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 ""
+
+#: C/image-viewer.cpp.page:208(p) C/image-viewer.c.page:216(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 ""
+
+#: C/image-viewer.cpp.page:213(p)
+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 ""
+
+#: C/image-viewer.c.page:8(desc)
+msgid "A little bit more than a simple \"Hello world\" Gtk application."
+msgstr ""
+
+#: C/image-viewer.c.page:26(p)
+msgid "Some basic concepts of C/GObject programming"
+msgstr ""
+
+#: C/image-viewer.c.page:27(p)
+msgid "How to write a Gtk application in C"
+msgstr ""
+
+#: C/image-viewer.c.page:41(p)
+msgid ""
+"Choose <gui>Gtk+ (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 ""
+
+#: C/image-viewer.c.page:44(p)
+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 ""
+
+#: C/image-viewer.c.page:59(p)
+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/image-viewer.c.page:63(p) C/guitar-tuner.c.page:68(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 ""
+
+#: C/image-viewer.c.page:66(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 ""
+
+#: C/image-viewer.c.page:67(p) C/guitar-tuner.vala.page:72(p)
+#: C/guitar-tuner.c.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> function is "
+"called (and quits the app) when you close the window."
+msgstr ""
+
+#: C/image-viewer.c.page:70(p) C/guitar-tuner.c.page:75(p)
+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 ""
+
+#: C/image-viewer.c.page:73(p) C/guitar-tuner.c.page:78(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 ""
+
+#: C/image-viewer.c.page:83(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 ""
+
+#: C/image-viewer.c.page:121(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 ""
+
+#: C/image-viewer.c.page:126(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 ""
+
+#: C/image-viewer.c.page:132(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 ""
+
+#: C/image-viewer.c.page:137(p)
+msgid ""
+"The last <code>g_signal_connect()</code> makes sure that the application "
+"exits when the window is closed."
+msgstr ""
+
+#: C/image-viewer.c.page:140(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 ""
+
+#: C/image-viewer.c.page:148(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 ""
+
+#: C/image-viewer.c.page:186(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 ""
+
+#: C/image-viewer.c.page:192(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 ""
+
+#: C/image-viewer.c.page:199(p)
+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 ""
+
+#: C/image-viewer.c.page:202(p)
+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 ""
+
+#: C/image-viewer.c.page:204(p)
+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 ""
+
+#: C/image-viewer.c.page:207(p)
+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 ""
+
+#: C/image-viewer.c.page:221(p)
+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 ""
+
+#. 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:37(None) C/guitar-tuner.py.page:37(None)
+#: C/guitar-tuner.cpp.page:37(None) C/guitar-tuner.c.page:37(None)
+msgid "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+msgstr "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+
+#. 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:89(None) C/guitar-tuner.py.page:88(None)
+#: C/guitar-tuner.cpp.page:88(None) C/guitar-tuner.c.page:92(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:134(None) C/guitar-tuner.py.page:131(None)
+#: C/guitar-tuner.cpp.page:117(None) C/guitar-tuner.c.page:137(None)
+msgid ""
+"@@image: 'media/guitar-tuner-pipeline.png'; "
+"md5=5adc952909d92af5dae6954781b4ad5f"
+msgstr ""
+"@@image: 'media/guitar-tuner-pipeline.png'; "
+"md5=5adc952909d92af5dae6954781b4ad5f"
+
+#: C/guitar-tuner.vala.page:8(desc) C/guitar-tuner.py.page:8(desc)
+#: C/guitar-tuner.c.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."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:21(title) C/guitar-tuner.py.page:21(title)
+#: C/guitar-tuner.cpp.page:21(title) C/guitar-tuner.c.page:21(title)
+msgid "Guitar Tuner"
+msgstr "Gitarrenstimmgerät"
+
+#: C/guitar-tuner.vala.page:24(p) C/guitar-tuner.py.page:24(p)
+#: C/guitar-tuner.cpp.page:24(p) C/guitar-tuner.c.page:24(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.vala.page:26(p) C/guitar-tuner.py.page:26(p)
+#: C/guitar-tuner.cpp.page:26(p) C/guitar-tuner.c.page:26(p)
+msgid "Set up a basic project in Anjuta"
+msgstr ""
+
+#: C/guitar-tuner.vala.page:27(p) C/guitar-tuner.py.page:27(p)
+#: C/guitar-tuner.cpp.page:27(p) C/guitar-tuner.c.page:27(p)
+msgid "Create a simple GUI with Anjuta's UI designer"
+msgstr ""
+
+#: C/guitar-tuner.vala.page:28(p) C/guitar-tuner.py.page:28(p)
+#: C/guitar-tuner.cpp.page:28(p) C/guitar-tuner.c.page:28(p)
+msgid "Use GStreamer to play sounds"
+msgstr ""
+
+#: C/guitar-tuner.vala.page:33(p)
+msgid "Basic knowledge of the Vala programming language"
+msgstr ""
+
+#: C/guitar-tuner.vala.page:47(p)
+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 ""
+
+#: C/guitar-tuner.vala.page:50(p) C/guitar-tuner.c.page:50(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 "
+"GStreamer library in your project."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:54(p)
+msgid ""
+"Click <gui>Finished</gui> and the project will be created for you. Open "
+"<file>src/guitar_tuner.vala</file> from the <gui>Project</gui> or <gui>File</"
+"gui> tabs. You should see some code which starts with the lines:"
+msgstr ""
+
+#: C/guitar-tuner.vala.page:64(p)
+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/guitar-tuner.vala.page:71(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. 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 ""
+
+#: C/guitar-tuner.vala.page:75(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 ""
+
+#: C/guitar-tuner.vala.page:84(title) C/guitar-tuner.py.page:83(title)
+#: C/guitar-tuner.cpp.page:83(title) C/guitar-tuner.c.page:87(title)
+msgid "Create the user interface"
+msgstr ""
+
+#: C/guitar-tuner.vala.page:85(p) C/guitar-tuner.py.page:84(p)
+#: C/guitar-tuner.cpp.page:84(p) C/guitar-tuner.c.page:88(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 ""
+
+#: C/guitar-tuner.vala.page:87(p) C/guitar-tuner.py.page:86(p)
+#: C/guitar-tuner.cpp.page:86(p) C/guitar-tuner.c.page:90(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 ""
+
+#: C/guitar-tuner.vala.page:93(p) C/guitar-tuner.py.page:92(p)
+#: C/guitar-tuner.cpp.page:92(p) C/guitar-tuner.c.page:96(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 ""
+
+#: C/guitar-tuner.vala.page:97(p) C/guitar-tuner.py.page:96(p)
+#: C/guitar-tuner.cpp.page:96(p) C/guitar-tuner.c.page:100(p)
+msgid ""
+"Now, choose a <gui>GtkButton</gui> from the palette and put it into the first "
+"part of the box."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:100(p) C/guitar-tuner.py.page:99(p)
+#: C/guitar-tuner.c.page:103(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 ""
+
+#: C/guitar-tuner.vala.page:103(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>main_on_button_clicked</code> in the <gui>Handler</gui> column and "
+"press <key>Return</key>."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:106(p) C/guitar-tuner.py.page:105(p)
+#: C/guitar-tuner.c.page:109(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 ""
+
+#: C/guitar-tuner.vala.page:109(p) C/guitar-tuner.py.page:108(p)
+#: C/guitar-tuner.c.page:112(p)
+msgid ""
+"Save the UI design (by clicking <guiseq><gui>File</gui><gui>Save</gui></"
+"guiseq>) and keep it open."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:115(title) C/guitar-tuner.c.page:118(title)
+msgid "Creating the signal handler"
+msgstr ""
+
+#: C/guitar-tuner.vala.page:116(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. 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 ""
+
+#: C/guitar-tuner.vala.page:117(p)
+msgid ""
+"To do this, open <file>guitar_tuner.vala</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 the beginning of the class. The "
+"following code will be added to your source file:"
+msgstr ""
+
+#: C/guitar-tuner.vala.page:124(p)
+msgid ""
+"This signal handler has only one argument: the <code>Gtk.Widget</code> that "
+"called the function (in our case, always a <code>Gtk.Button</code>). The "
+"additonal <code>[CCode (instance_pos=-1)]</code> tells the compiler that this "
+"is a signal handler that needs special treating while linking in order to be "
+"found at runtime."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:126(p) C/guitar-tuner.py.page:123(p)
+#: C/guitar-tuner.c.page:129(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.vala.page:130(title) C/guitar-tuner.py.page:127(title)
+#: C/guitar-tuner.cpp.page:112(title) C/guitar-tuner.c.page:133(title)
+msgid "GStreamer pipelines"
+msgstr "GStreamer-Weiterleitungen"
+
+#: C/guitar-tuner.vala.page:131(p) C/guitar-tuner.py.page:128(p)
+#: C/guitar-tuner.c.page:134(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 ""
+
+#: C/guitar-tuner.vala.page:132(p) C/guitar-tuner.py.page:129(p)
+#: C/guitar-tuner.cpp.page:115(p) C/guitar-tuner.c.page:135(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 ""
+
+#: C/guitar-tuner.vala.page:133(p) C/guitar-tuner.py.page:130(p)
+#: C/guitar-tuner.cpp.page:116(p) C/guitar-tuner.c.page:136(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:135(p) C/guitar-tuner.py.page:132(p)
+#: C/guitar-tuner.cpp.page:118(p) C/guitar-tuner.c.page:138(p)
+msgid "An example GStreamer pipeline."
+msgstr "Eine Beispiel-Weiterleitung in GStreamer."
+
+#: C/guitar-tuner.vala.page:140(title) C/guitar-tuner.py.page:137(title)
+#: C/guitar-tuner.c.page:143(title)
+msgid "Set up the pipeline"
+msgstr "Einrichten der Weiterleitung"
+
+#: C/guitar-tuner.vala.page:141(p) C/guitar-tuner.py.page:138(p)
+#: C/guitar-tuner.cpp.page:129(p) C/guitar-tuner.c.page:144(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 ""
+
+#: C/guitar-tuner.vala.page:143(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 ""
+
+#: C/guitar-tuner.vala.page:145(p)
+msgid ""
+"Then, copy the following function into <file>guitar_tuner.vala</file> inside "
+"our <code>Main</code> class:"
+msgstr ""
+
+#: C/guitar-tuner.vala.page:180(p)
+msgid ""
+"The first five lines create source and sink GStreamer elements (<code>Gst."
+"Element</code>), and a pipeline element (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 ""
+
+#: C/guitar-tuner.vala.page:183(p)
+msgid ""
+"The call to <code>source.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 ""
+
+#: C/guitar-tuner.vala.page:186(p)
+msgid ""
+"<code>pipeline.add</code> puts the source and sink into the pipeline. The "
+"pipeline is a <code>Gst.Bin</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 calls to <code>pipeline.add</code>."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:189(p)
+msgid ""
+"Next, <code>sink.link</code> 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). <code>pipeline.set_state</code> is then used to start "
+"playback, by setting the state of the pipeline to playing (<code>Gst.State."
+"PLAYING</code>)."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:192(p)
+msgid ""
+"We don't want to play an annoying tone forever, so the last thing "
+"<code>play_sound</code> does is to add add a <code>TimeoutSource</code>. 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 ""
+
+#: C/guitar-tuner.vala.page:203(title)
+msgid "Define the signal handler"
+msgstr ""
+
+#: C/guitar-tuner.vala.page:204(p)
+msgid ""
+"We want to play the correct sound when the user clicks a button. For this, we "
+"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 ""
+
+#: C/guitar-tuner.vala.page:232(p)
+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 ""
+
+#: C/guitar-tuner.vala.page:233(p)
+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 ""
+
+#: C/guitar-tuner.vala.page:238(p) C/guitar-tuner.cpp.page:250(p)
+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 ""
+
+#: C/guitar-tuner.vala.page:239(p) C/guitar-tuner.cpp.page:251(p)
+#: C/guitar-tuner.c.page:251(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 ""
+
+#: C/guitar-tuner.vala.page:244(p)
+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 ""
+
+#: C/guitar-tuner.vala.page:258(p) C/guitar-tuner.py.page:235(p)
+#: C/guitar-tuner.cpp.page:272(p) C/guitar-tuner.c.page:264(p)
+msgid "Have the program automatically cycle through the notes."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:261(p) C/guitar-tuner.py.page:238(p)
+#: C/guitar-tuner.cpp.page:275(p) C/guitar-tuner.c.page:267(p)
+msgid "Make the program play recordings of real guitar strings being plucked."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:262(p) C/guitar-tuner.py.page:239(p)
+#: C/guitar-tuner.cpp.page:276(p) C/guitar-tuner.c.page:268(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 ""
+
+#: C/guitar-tuner.vala.page:263(p) C/guitar-tuner.py.page:240(p)
+#: C/guitar-tuner.cpp.page:277(p) C/guitar-tuner.c.page:269(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 ""
+
+#: C/guitar-tuner.vala.page:266(p) C/guitar-tuner.py.page:243(p)
+#: C/guitar-tuner.cpp.page:280(p) C/guitar-tuner.c.page:272(p)
+msgid "Automatically analyze notes that the user plays."
+msgstr ""
+
+#: C/guitar-tuner.vala.page:267(p) C/guitar-tuner.py.page:244(p)
+#: C/guitar-tuner.cpp.page:281(p) C/guitar-tuner.c.page:273(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 ""
+
+#: C/guitar-tuner.py.page:33(p)
+msgid "Basic knowledge of the Python programming language"
+msgstr ""
+
+#: C/guitar-tuner.py.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."
+msgstr ""
+
+#: C/guitar-tuner.py.page:50(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 ""
+
+#: C/guitar-tuner.py.page:59(title)
+msgid "Run the code for the first time"
+msgstr "Erste Ausführung des Codes"
+
+#: C/guitar-tuner.py.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:"
+msgstr ""
+
+#: C/guitar-tuner.py.page:64(p)
+msgid ""
+"The <code>import</code> lines at the top include the tell Python to load the "
+"user interface and system libraries needed."
+msgstr ""
+
+#: C/guitar-tuner.py.page:68(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 ""
+
+#: C/guitar-tuner.py.page:71(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 ""
+
+#: C/guitar-tuner.py.page:74(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 ""
+
+#: C/guitar-tuner.py.page:79(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 ""
+
+#: C/guitar-tuner.py.page:102(p) C/guitar-tuner.c.page:106(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 ""
+
+#: C/guitar-tuner.py.page:114(title)
+msgid "Write the signal handler"
+msgstr ""
+
+#: C/guitar-tuner.py.page:115(p) C/guitar-tuner.c.page:119(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 ""
+
+#: C/guitar-tuner.py.page:116(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:"
+msgstr ""
+
+#: C/guitar-tuner.py.page:122(p)
+msgid ""
+"This signal handler has two arguments: the usual Python class pointer, and "
+"the <code>Gtk.Button</code> that called the function."
+msgstr ""
+
+#: C/guitar-tuner.py.page:140(p)
+msgid ""
+"Change the import line in <file>guitar_tuner.py</file>, just at the beginning "
+"to :"
+msgstr ""
+
+#: C/guitar-tuner.py.page:142(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 ""
+
+#: C/guitar-tuner.py.page:146(p)
+msgid ""
+"Then, copy the following function into the main class in <file>guitar_tuner."
+"py</file> somewhere:"
+msgstr ""
+
+#: C/guitar-tuner.py.page:161(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 ""
+
+#: C/guitar-tuner.py.page:164(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 ""
+
+#: C/guitar-tuner.py.page:167(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 ""
+
+#: C/guitar-tuner.py.page:170(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 ""
+
+#: C/guitar-tuner.py.page:177(title) C/guitar-tuner.c.page:193(title)
+msgid "Stopping playback"
+msgstr "Die Wiedergabe stoppen"
+
+#: C/guitar-tuner.py.page:178(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 ""
+
+#: C/guitar-tuner.py.page:179(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 ""
+
+#: C/guitar-tuner.py.page:185(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 ""
+
+#: C/guitar-tuner.py.page:190(p)
+msgid ""
+"The call to <code>pipeline.set_state</code> pauses the playback of the "
+"pipeline."
+msgstr ""
+
+#: C/guitar-tuner.py.page:194(title) C/guitar-tuner.c.page:211(title)
+msgid "Define the tones"
+msgstr ""
+
+#: C/guitar-tuner.py.page:195(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 ""
+
+#: C/guitar-tuner.py.page:208(p) C/guitar-tuner.c.page:221(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 ""
+
+#: C/guitar-tuner.py.page:216(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 ""
+
+#: C/guitar-tuner.py.page:217(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 ""
+
+#: C/guitar-tuner.py.page:222(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 ""
+
+#: C/guitar-tuner.py.page:227(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 ""
+
+#: C/guitar-tuner.cpp.page:8(desc)
+msgid ""
+"Use Gtkmm and GStreamermm to build a simple guitar tuner application for "
+"GNOME. Shows off how to use the interface designer."
+msgstr ""
+
+#: C/guitar-tuner.cpp.page:33(p)
+msgid "Basic knowledge of the C++ programming language"
+msgstr ""
+
+#: C/guitar-tuner.cpp.page:47(p)
+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 ""
+
+#: 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 ""
+
+#: C/guitar-tuner.cpp.page:54(p)
+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 ""
+
+#: C/guitar-tuner.cpp.page:64(p)
+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/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 ""
+
+#: 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 ""
+
+#: 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 ""
+
+#: 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. "
+"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 ""
+
+#: C/guitar-tuner.cpp.page:103(p)
+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 ""
+
+#: C/guitar-tuner.cpp.page:106(p)
+msgid ""
+"Save the UI design (by clicking <guiseq><gui>File</gui><gui>Save</gui></"
+"guiseq>) and close the file."
+msgstr ""
+
+#: 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. GStreamermm is the C++ "
+"binding to GStreamer which we will use here."
+msgstr ""
+
+#: C/guitar-tuner.cpp.page:123(title)
+msgid "Using GStreamermm"
+msgstr "Verwendung von 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 ""
+
+#: 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 ""
+
+#: 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 ""
+
+#: C/guitar-tuner.cpp.page:178(p)
+msgid "The code has the following purpose:"
+msgstr "Der Code hat den folgenden Zweck:"
+
+#: C/guitar-tuner.cpp.page:181(p)
+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 ""
+
+#: 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 ""
+
+#: C/guitar-tuner.cpp.page:189(p)
+msgid ""
+"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 ""
+
+#: C/guitar-tuner.cpp.page:197(title)
+msgid "Connecting the signals"
+msgstr "Verbinden der Signale"
+
+#: C/guitar-tuner.cpp.page:198(p)
+msgid ""
+"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 ""
+
+#: 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 ""
+
+#: 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 ""
+
+#: 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 ""
+
+#: 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 ""
+
+#: 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.cc\">reference code</link>."
+msgstr ""
+
+#: C/guitar-tuner.cpp.page:260(title)
+msgid "Further Reading"
+msgstr "Weitere Informationen"
+
+#: 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 ""
+
+#: C/guitar-tuner.c.page:33(p)
+msgid "Basic knowledge of the C programming language"
+msgstr ""
+
+#: C/guitar-tuner.c.page:47(p)
+msgid ""
+"Choose <gui>Gtk+ (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 ""
+
+#: C/guitar-tuner.c.page:64(p)
+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/guitar-tuner.c.page:71(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 ""
+
+#: C/guitar-tuner.c.page:120(p)
+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 ""
+
+#: C/guitar-tuner.c.page:128(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 ""
+
+#: C/guitar-tuner.c.page:146(p)
+msgid ""
+"Insert the following line into <file>main.c</file>, just below the <code><!"
+"[CDATA[#include <gtk/gtk.h>]]></code> line:"
+msgstr ""
+
+#: C/guitar-tuner.c.page:148(p)
+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 ""
+
+#: C/guitar-tuner.c.page:150(p)
+msgid ""
+"Then, copy the following function into <file>main.c</file> above the empty "
+"<code>on_button_clicked</code> function:"
+msgstr ""
+
+#: C/guitar-tuner.c.page:177(p)
+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 ""
+
+#: C/guitar-tuner.c.page:180(p)
+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 ""
+
+#: C/guitar-tuner.c.page:183(p)
+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 ""
+
+#: C/guitar-tuner.c.page:186(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 ""
+
+#: C/guitar-tuner.c.page:194(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>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 ""
+
+#: C/guitar-tuner.c.page:195(p)
+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 ""
+
+#: C/guitar-tuner.c.page:207(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 ""
+
+#: C/guitar-tuner.c.page:212(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 top of <file>main.c</file>) as follows:"
+msgstr ""
+
+#: C/guitar-tuner.c.page:244(p)
+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 ""
+
+#: C/guitar-tuner.c.page:245(p)
+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 ""
+
+#: C/guitar-tuner.c.page:256(p)
+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 ""
+
+#. 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:40(None)
+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:45(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:50(None)
+msgid "@@image: 'media/opensuse.png'; md5=a852a94199328e2f978c7f6a55bf8b54"
+msgstr "@@image: 'media/opensuse.png'; md5=a852a94199328e2f978c7f6a55bf8b54"
+
+#: C/getting-ready.page:8(desc)
+msgid "Install GNOME development tools"
+msgstr ""
+
+#: C/getting-ready.page:17(title)
+msgid "Getting ready for GNOME development"
+msgstr ""
+
+#: C/getting-ready.page:20(title)
+msgid "Install the required tools"
+msgstr ""
+
+#: C/getting-ready.page:21(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 ""
+
+#: C/getting-ready.page:26(title)
+msgid "Automatic installation"
+msgstr "Automatische Installation"
+
+#: C/getting-ready.page:27(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 ""
+
+#: C/getting-ready.page:25(section)
+msgid "<placeholder-1/><placeholder-2/>."
+msgstr "<placeholder-1/><placeholder-2/>."
+
+#: C/getting-ready.page:32(title)
+msgid "Manual installation"
+msgstr "Manuelle Installation"
+
+#: C/getting-ready.page:33(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 ""
+
+#: C/getting-ready.page:40(p)
+msgid "Ubuntu"
+msgstr "Ubuntu"
+
+#: C/getting-ready.page:45(p)
+msgid "Fedora"
+msgstr "Fedora"
+
+#: C/getting-ready.page:50(p)
+msgid "OpenSuSE"
+msgstr "OpenSuSE"
+
+#: C/getting-ready.page:53(link)
+msgid "Others"
+msgstr "Weitere"
+
+#: C/getting-ready.page:60(title)
+msgid "Required versions"
+msgstr "Erforderliche Versionen"
+
+#: C/getting-ready.page:61(p)
+msgid ""
+"The guides assume that you have at least the following versions of the tools "
+"installed:"
+msgstr ""
+
+#: C/getting-ready.page:64(p)
+msgid "Anjuta - 3.0"
+msgstr "Anjuta - 3.0"
+
+#: C/getting-ready.page:65(p)
+msgid "Devhelp - 3.0"
+msgstr "Devhelp - 3.0"
+
+#: C/getting-ready.page:66(p)
+msgid "Glade - 3.10"
+msgstr "Glade - 3.10"
+
+#: C/getting-ready.page:68(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 ""
+"Natürlich wird auch jede neuere Version funktionieren. Wir wünschen Ihnen nun "
+"viel SpaÃ? mit den <link xref=\"index\">Demos</link>."
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2
+#: C/index.page:0(None)
+msgid "translator-credits"
+msgstr "Mario Blättermann <mariobl freenet de>, 2011"