gnome-devel-docs - en to cs translation catalogue (2269 entries)

note: (itstool) path: info/desc
en: Learn how to lay out UI components, like Images and Labels.
cs: Naučte se, jak rozvrhnout komponenty uživatelského rozhraní, jako jsou obrázky a popisky.

note: (itstool) path: page/title
en: 2. Welcome to the Grid
cs: 2. Vítejte v mřížce

note: (itstool) path: synopsis/p
en: This tutorial will show you how to create basic widgets, or parts of the GNOME user interface, like Images and Labels. You'll then learn how to arrange them all in a Grid, which lets you put widgets exactly where you want them.
cs: V této lekci si ukážeme, jak vytvořit základní widgety nebo části uživatelského rozhraní GNOME, jako jsou obrázky (Image) a popisky (Label). Po té se naučíte, jak je uspořádat do mřížky (Grid), která vám umožní umístit widgety právě tam, kde je chcete.

note: (itstool) path: note/p
en: Have you taken <link xref="hellognome.js">the first tutorial in this series</link> already? You'll want to do so before continuing.
cs: Prošli jste již <link xref="hellognome.js">první lekcí v této sérii</link>? Než budete pokračovat, bylo by to dobré udělat.

note: (itstool) path: section/title
en: Going native
cs: Buďme přirození

note: (itstool) path: section/p
en: In the last tutorial, we created what was basically a GNOME window frame for a web app. All the GNOME-specific code we needed to learn revolved around putting the WebView -- the widget containing our application -- into an ApplicationWindow, and telling it to display. The application itself was written in HTML and JavaScript, just like most pages on the web.
cs: V předchozí lekci jsme vytvořili něco, co bylo v podstatě okno GNOME s rámem pro webovou aplikaci. Vše, co jsme se potřebovali naučit z kódu specifického pro GNOME, se točilo okolo vložení WebView – widgetu obsahujícího naši aplikaci – do ApplicationWindow a jak mu říct, aby se zobrazil. K napsání vlastní aplikace byly použity HTML a JavaScript, podobně jako u webových stránek.

note: (itstool) path: section/p
en: This time, we're going to use only native GNOME widgets. A widget is just a thing, like a checkbox or picture, and GNOME has a wide variety of them to choose from. We call them "native" widgets to distinguish them from things like the button and header in the web app we wrote. Because instead of using web code, these are going to be 100 percent GNOME, using GTK+.
cs: Tentokrát budeme používat jen nativní widgety GNOME. Widget je prostě věc, jako zaškrtávací políčko nebo obrázek, a GNOME jich má širokou nabídku, ze které můžete vybírat. Nazýváme je „nativní“ widgety kvůli odlišení od věcí, jako jsou tlačítka nebo nadpisy ve webové aplikaci, kterou jsme napsali. Protože místo webového kódu použijeme GTK+, půjde o 100% aplikaci GNOME.

note: (itstool) path: note/p
en: GTK+ stands for "GIMP Toolkit". It's like a toolbox of widgets that you can reach into, while building your applications. It was originally written for <link href="http://www.gimp.org/">the GIMP</link>, which is a free software image editor.
cs: GTK+ je zkratka pro „GIMP Toolkit“. Je to nástrojová sada widgetů, po kterých můžeme sáhnout, když stavíme naši aplikaci. Původně byly napsány pro <link href="http://www.gimp.org/">GIMP</link>, což je svobodný grafický editor.

note: (itstool) path: section/title
en: Setting up our application
cs: Nastavení vaší aplikace

note: (itstool) path: section/p
en: Before we dig out any widgets from the GTK+ toolbox, we first need to write the basic boilerplate code that our application requires.
cs: Než začneme tahat widgety z nástrojové sady GTK+, musíme nejdříve napsat základní kód, který aplikace vyžaduje a tak se s ním setkáte často.

note: (itstool) path: section/p
en: This part always goes at the start of your code. Depending on what you'll be doing with it, you may want to declare more imports here. What we're writing today is pretty basic, so these are all we need; Gtk for the widgets, using the stable '3.0' API.
cs: Tato část je vždy na začátku kódu. V závislosti na tom, co přesně hodláte dělat, zde můžete deklarovat i další importy. To, co píšeme teď, je docela jednoduché, takže nám to bude stačit takto. Gtk pro widgety používající stabilní API 3.0.

note: (itstool) path: section/p
en: Speaking of which:
cs: Když už o tom mluvíme:

note: (itstool) path: section/code
en: 
    class WelcomeToTheGrid {
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application();
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI ();
        }
cs: 
    class WelcomeToTheGrid {
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application();
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazující okno při aktivaci
        _onActivate: function () {
            this._window.present ();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function () {
            this._buildUI ();
        },

note: (itstool) path: section/p
en: This is the start of the application itself, and the _init function which creates it. It tells _buildUI to create an ApplicationWindow, which we're going to call _window, and it tells our window to present itself whenever needed.
cs: Toto je začátek vlastní aplikace a funkce <code>_init</code> ji vytvoří. Aplikace pak řekne funkci <code>_buildUI</code>, aby vytvořila ApplicationWindow, který budeme nazývat <var>_window</var> a našemu oknu se říká, aby se zobrazilo, kdykoliv je potřeba.

note: (itstool) path: section/p
en: This part, again, is pretty much copy-and-paste, but you always want to give your application a unique name.
cs: Tato část je opět do značné míry vytvořena stylem kopírovat-a-vložit, akorát je potřeba dát aplikaci vždy jedinečný název.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 10,
                title: "Welcome to the Grid"});
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 10,
                title: "Welcome to the Grid"});

note: (itstool) path: section/p
en: Finally, we start off the _buildUI function by creating a new ApplicationWindow. We specify that it goes with this application, that it should appear in the center of the screen, and that there should be at least 10 pixels between the outside edge and any widgets inside of it. We also give it a title, which will appear at the top of the window.
cs: Nakonec spustíme funkci <code>_buildUI</code> vytvořením nového ApplicationWindow. Určíme naší aplikaci, že se má objevit uprostřed obrazovky a že by mělo být nejméně 10 pixelů mezi vnější hranou a widgety uvnitř. Rovněž ji přidělíme název, který se objeví v záhlaví okna.

note: (itstool) path: section/title
en: Reaching into the GTK+ toolbox
cs: Po čem sáhnout do nástrojové sady GTK+

note: (itstool) path: section/p
en: What widgets should we use? Well, let's say we want to write an application that looks like this:
cs: Které widgety bychom měli použít? Řekněme, že chceme napsat aplikaci, která vypadá nějak takto:

note: (itstool) path: section/p
en: We're going to need, at the very least, a picture and a text label to go with it. Let's start with the picture:
cs: K tomu budeme potřebovat aspoň obrázek a textový popisek. Začněme obrázkem:

note: (itstool) path: section/code
en: 
            // Create an image
            this._image = new Gtk.Image ({ file: "gnome-image.png" });
cs: 
            // Vytvoří obrázek
            this._image = new Gtk.Image ({ file: "gnome-image.png" });

note: (itstool) path: section/p
en: You can download the image file used in this example <link href="https://live.gnome.org/TarynFox?action=AttachFile&amp;do=get&amp;target=gnome-image.png">here</link>. Be sure to put it in the same directory as the code you're writing.
cs: Obrázek použitý v tomto příkladu si můžete stáhnout <link href="https://live.gnome.org/TarynFox?action=AttachFile&amp;do=get&amp;target=gnome-image.png">zde</link>. Zajistěte, aby byl uložený ve stejné složce, jako kód, který píšete.

note: (itstool) path: section/code
en: 
            // Create a label
            this._label = new Gtk.Label ({ label: "Welcome to GNOME, too!" });
cs: 
            // Vytvoří popisek
            this._label = new Gtk.Label ({ label: "Welcome to GNOME, too!" });

note: (itstool) path: section/p
en: That code adds in the label beneath. You can see how we create widgets, here; each one is a part of Gtk, and we can give it properties that customize how it behaves. In this case, we set the Image's file property to be the filename of the picture we want, and the Label's label property to be the sentence that we want beneath the picture.
cs: Tento kód pod něj přidá popisek. Zde můžete vidět, jak se vytváří widgety. Všechny jsou součástí Gtk a mi jim udáváme vlastnosti, kterými si přizpůsobíme, jak se mají chovat. V tomto případě widgetu Image nastavíme vlastnost <code>file</code> na název souboru s obrázkem a popisku vlastnost <code>label</code> na větu, kterou chceme mít pod obrázkem.

note: (itstool) path: note/p
en: Yes, it sounds redundant for a Label to have a label property, but it's not. Other widgets that contain text have a label property, so it's <em>consistent</em> for the Label widget to have one too.
cs: Ano, to že má Label vlastnost label vypadá jako zdvojování, ale není tomu tak. Ostatní widgety, které obsahují text, mají vlastnost <code>label</code>, takže kvůli <em>jednotnosti</em> je tomu tak i u widgetu Label.

note: (itstool) path: section/p
en: We can't just add these widgets to our window in order, though, the same way HTML elements appear in the order you write them. That's because an ApplicationWindow can only contain one widget.
cs: Tyto widgety nemůžeme do našeho okna jen tak přidat ve správném pořadí, podobně jako se to dělá s prvky HTML na webové stránce. Kvůli tomu, že ApplicationWindow může obsahovat jen jeden widget.

note: (itstool) path: section/p
en: How do we get around that? By making that one widget a container widget, which can hold more than one widget and organize them inside it. Behold: The Grid.
cs: Co s tím? Vytvoříme kontejnerový widget, který může obsahovat více než jeden widget a umí je uspořádat. Pohleďte: mřížka.

note: (itstool) path: section/code
en: 
            // Create the Grid
            this._grid = new Gtk.Grid ();
cs: 
            // Vytvoří mřížku
            this._grid = new Gtk.Grid ();

note: (itstool) path: section/p
en: We're not giving it any properties yet. Those will come later, as we learn how to use the Grid's powers. First, let's attach the Image and Label we made to our Grid.
cs: Neudali jsme jí žádné vlastnosti. To uděláme až později, až se naučíme s mřížkou pořádně zacházet. Nejprve pojďme do námi vytvořené mřížky připojit obrázek a popisek.

note: (itstool) path: section/code
en: 
            // Attach the image and label to the grid
            this._grid.attach (this._image, 0, 0, 1, 1);
            this._grid.attach (this._label, 0, 1, 1, 1);
cs: 
            // Připojení obrázku a popisku do mřížky
            this._grid.attach (this._image, 0, 0, 1, 1);
            this._grid.attach (this._label, 0, 1, 1, 1);

note: (itstool) path: section/p
en: This code looks awfully complicated, but it's not. Here's what those numbers mean:
cs: Tento kód vypadá strašně složitě, ale není tomu tak. Zde je popsáno, co jednotlivá čísla znamenají:

note: (itstool) path: item/p
en: The <em>first</em> number is what left-to-right position to put things in, starting from 0. Any widget that uses a 0 here goes all the way to the left.
cs: <em>První</em> číslo je pozice ve směru zleva doprava, na kterou se má widget umístit, počínaje od 0. Widget, který použije 0, patří úplně doleva.

note: (itstool) path: item/p
en: The <em>second</em> number is what top-to-bottom position to put a given widget in, starting from 0. The Label goes beneath the Image, so we give the Image a 0 and the Label a 1 here.
cs: <em>Druhé</em> číslo je pozice ve směru shora dolů, na kterou se má daný widget umístit, počínaje od 0. Popisek má být pod obrázkem, takže widget Image dostane pozici 0 a Label pozici 1.

note: (itstool) path: item/p
en: The <em>third</em> and <em>fourth</em> numbers are how many columns and rows a widget should take up. We'll see how these work in a minute.
cs: <em>Třetí</em> a <em>čtvrté</em> číslo udává kolik sloupců a řádků má widget okupovat. Za minutku uvidíme, jak to funguje.

note: (itstool) path: section/code
en: 
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
    };
    
    // Run the application
    let app = new WelcomeToTheGrid ();
    app.application.run (ARGV);
cs: 
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
    };
    
    // Spustí aplikaci
    let app = new WelcomeToTheGrid ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Now that we've created the Grid and attached all our widgets to it, we add it to the window and tell the window to show itself, as the last part of the _buildUI function. As always, to finish up we create a new instance of the application's class and tell it to run.
cs: Nyní máme vytvořenou mřížku a do ní připojené všechny naše widgety, přidali jsme ji do okna a oknu, jako poslední část funkce _buildUI, řekli, ať se zobrazí. Jako vždy končíme vytvořením nové instance třídy aplikace a jejím spuštěním.

note: (itstool) path: section/p
en: Save your application as welcome_to_the_grid.js. Then, to run your application just open a terminal, go to the directory where your application is at, and type
cs: Uložte svoji aplikaci jako <file>welcome_to_the_grid.js</file>. Následně ji spusťte tak, že otevřete terminál, přepnete se do složky, ve které je vaše aplikace, a napíšete:

note: (itstool) path: section/p
en: There we go! But wait. That doesn't look right. Why is the Label crammed up next to the Image like that? That doesn't look as nice, and it makes it harder to read. What can we do about this?
cs: Ono to funguje! Ale… Nevypadá to úplně hezky. Proč je popisek nalepený těsně na obrázek? To jednak není estetické a jedna se to špatně čte. Co s tím můžeme udělat?

note: (itstool) path: section/title
en: Tweaking the Grid
cs: Vyladění mřížky

note: (itstool) path: section/p
en: One thing we can do, is we can give the Label a margin_top property when we create it. This works sort of like setting a margin for an HTML element using inline CSS styling.
cs: Jedna z věcí, kterou můžeme udělat, je udat popisku při vytváření vlastnost <code>margin_top</code>. Funguje to podobně, jako nastavení vlastnosti „margin“ u prvků HTML pomocí stylování CSS.

note: (itstool) path: section/code
en: 
            // Create a label
            this._label = new Gtk.Label ({
                label: "Welcome to GNOME, too!",
                margin_top: 20 });
cs: 
            // Vytvoří popisek
            this._label = new Gtk.Label ({
                label: "Welcome to GNOME, too!",
                margin_top: 20 });

note: (itstool) path: section/p
en: Of course, if we do that then if we replace the Label with something else -- or add in another widget -- then we have to repeat the margin_top on it too. Otherwise we end up with something like this:
cs: Samozřejmě, že když popisek nahradíme něčím jiným, nebo přidáme další widget, musíme nastavení <code>margin_top</code> zopakovat i u něj. Jinak s končíme s něčím takovýmto:

note: (itstool) path: section/p
en: We could give the Image a margin_bottom property, but that won't work when the new Label is in a separate column. So how about we try this instead:
cs: Mohli bychom udat vlastnost <code>margin_bottom</code> u obrázku, ale to by nefungovalo správně, když by nový popisek byl v jiném sloupci. Takže pojďme to místo toho zkusit takto:

note: (itstool) path: section/code
en: 
            // Create the Grid
            this._grid = new Gtk.Grid ({
                row_spacing: 20 });
cs: 
            // Vytvoří mřížku
            this._grid = new Gtk.Grid ({
                row_spacing: 20 });

note: (itstool) path: section/p
en: That makes it so that there are always 20 pixels of space in between each horizontal row.
cs: To zajistí, že vodorovně mezi všemi řádky bude vždy prostor 20 pixelů.

note: (itstool) path: note/p
en: Yes, you can also set the column_spacing property on a Grid, or the margin_left and margin_right properties on any widget. Try them out, if you like!
cs: Ano, obdobně můžeme nastavit vlastnost mřížky <code>column_spacing</code> nebo vlastnosti <code>margin_left</code> a <code>margin_right</code> u libovolného widgetu. Jestli chcete, vyzkoušejte si to!

note: (itstool) path: section/title
en: Adding more widgets
cs: Přidání dalších widgetů

note: (itstool) path: section/p
en: If we did want to add a second Label, how would we do it so that it actually looked like it belonged there? One way is to center the Image on top, so that it's above both Labels instead of just the one on the left. That's where those other numbers in the Grid's attach method come in:
cs: Pokud bychom chtěli přidat druhý popisek, jak bychom to vlastně měli udělat, aby to na pohled vypadalo, že tam patří? Jedním ze způsobů je obrázek nahoře umístit na střed, tak aby byl nad oběma popisky a ne jen nad jedním vlevo. To je ta situace, kdy ostatní čísla u metody pro připojení do mřížky, přijdou vhod:

note: (itstool) path: section/code
en: 
            // Create a second label
            this._labelTwo = new Gtk.Label ({
                label: "The cake is a pie." });
    
            // Attach the image and labels to the grid
            this._grid.attach (this._image, 0, 0, 2, 1);
            this._grid.attach (this._label, 0, 1, 1, 1);
            this._grid.attach (this._labelTwo, 1, 1, 1, 1);
cs: 
            // Vytvoří druhý popisek
            this._labelTwo = new Gtk.Label ({
                label: "The cake is a pie." });
    
            // Připojí obrázek a popisky do mřížky
            this._grid.attach (this._image, 0, 0, 2, 1);
            this._grid.attach (this._label, 0, 1, 1, 1);
            this._grid.attach (this._labelTwo, 1, 1, 1, 1);

note: (itstool) path: section/p
en: After we create the second Label, we attach it to the Grid to the right of the first Label. Remember, the first two numbers count columns and rows from left to right and top to bottom, starting with 0. So if the first Label is in column 0 and row 1, we can put the second in column 1 and row 1 to put it to the right of the first Label.
cs: Po té, co vytvoříme druhý popisek, připojíme jej do mřížky napravo od prvního popisku. Pamatujete, že první dvě čísla udávají číslo sloupce a řádku zleva doprava a shora dolů, počítáno od 0? Takže, když je první popisek v sloupci 0 a řádku 1, můžeme vložit druhý do sloupce 1 a řádku 1, aby byl napravo od prvního.

note: (itstool) path: section/p
en: Note the number 2 in the attach statement for the Image. That's what does the trick here. That number is how many columns the Image spans, remember? So when we put it together, we get something like this:
cs: Podívejme se na číslo 2 ve výrazu pro připojení obrázku. V něm je ten trik. Toto číslo znamená, přes kolik sloupců se obrázek roztáhne, pamatujete? Takže, když to dáme vše dohromady, dostaneme něco takového:

note: (itstool) path: section/p
en: There are two things you should take note of, here.
cs: Jsou zde dvě věci, které byste měli vzít na vědomí.

note: (itstool) path: item/p
en: Setting the Image to span two columns doesn't stretch the picture itself horizontally. Instead, it stretches the invisible box taken up by the Image widget to fill both columns, then places the Image in the center of that box.
cs: Natavení obrázku, aby zabíral dva sloupce, přímo obrázek nijak neroztáhne. Místo toho roztáhne neviditelný box obsazený widgetem Image tak, aby zaplnil oba sloupce a obrázek pak umístí do středu tohoto boxu.

note: (itstool) path: item/p
en: Even though we've set the Grid's row_spacing and the ApplicationWindow's border_width properties, we haven't yet set anything that puts a border in between the two Labels. They were separate earlier when the Image was in only one column, but now that it spans both GNOME doesn't see a reason to keep them apart.
cs: I když jsme nastavili vlastnosti <code>row_spacing</code> u mřížky a <code>border_width</code> u okna aplikace, nemáme zatím nic, co by vložilo okraj mezi dva popisky. Dříve byly odděleny díky tomu, že obrázek zabíral jen jeden sloupec, ale nyní, když je roztažen přes oba sloupce, nevidí GNOME důvod k tomu, držet popisky oddělené.

note: (itstool) path: section/p
en: There are at least three ways we can get around that last one. First, we can set a margin_left or margin_right on one of the Labels:
cs: Existují aspoň tři způsoby, jak vyřešit druhou záležitost. Jako první můžeme nastavit u jednoho z popisků <code>margin_left</code> nebo <code>margin_right</code>:

note: (itstool) path: section/p
en: Second, we can set the Grid's column_homogeneous property to true.
cs: Zadruhé můžeme nastavit vlastnost mřížky <code>column_homogenous</code> na <code>true</code>.

note: (itstool) path: section/code
en: 
            // Create the Grid
            this._grid = new Gtk.Grid ({
                column_homogeneous: true,
                row_spacing: 20 });
cs: 
            // Vytvoří mřížku
            this._grid = new Gtk.Grid ({
                column_homogeneous: true,
                row_spacing: 20 });

note: (itstool) path: section/p
en: That makes it look something like this:
cs: Ve výsledku to bude vypadat nějak takto:

note: (itstool) path: section/p
en: And third, we can set the Grid's column_spacing property, the same way we set its row_spacing.
cs: A zatřetí můžeme nastavit vlastnost mřížky <code>column_spacing</code>, stejným způsobem jako její vlastnost <code>row_spacing</code>.

note: (itstool) path: section/code
en: 
            // Create the Grid
            this._grid = new Gtk.Grid ({
                column_spacing: 20,
                row_spacing: 20 });
cs: 
            // Vytvoří mřížku
            this._grid = new Gtk.Grid ({
                column_spacing: 20,
                row_spacing: 20 });

note: (itstool) path: section/p
en: That makes it look like this:
cs: Ve výsledku to bude vypadat takto:

note: (itstool) path: section/title
en: Using stock images
cs: Používání standardních obrázků

note: (itstool) path: section/p
en: GNOME has a lot of stock images on hand already, that we can use if we don't feel like creating our own or if we want a universally-recognized icon. Here's how we create a stock image, compared to how we create a normal one:
cs: GNOME má připravenou spoustu standardních obrázků, které můžete použít, kdy se necítíte na vytvoření vlastních nebo chcete použít obecně známou ikonu. Zde je, jak vytvořit standardní obrázek, pro srovnání s tím, jak vytvořit ten normální:

note: (itstool) path: section/code
en: 
            // Create an image
            this._image = new Gtk.Image ({ file: "gnome-image.png" });
    
            // Create a second image using a stock icon
            this._icon = new Gtk.Image ({ stock: 'gtk-about' });
cs: 
            // Vytvoří obrázek
            this._image = new Gtk.Image ({ file: "gnome-image.png" });
    
            // Vytvoří druhý obrázek pomocí standardní ikony
            this._icon = new Gtk.Image ({ stock: 'gtk-about' });

note: (itstool) path: section/p
en: After that, we attach it to the Grid to the left of the first Label. (We aren't using the second one for this example.)
cs: Po té jej připojíme do mřížky nalevo od prvního popisku. (V tomto příkladu nevyužijeme druhý popisek.)

note: (itstool) path: section/code
en: 
            // Attach the images and label to the grid
            this._grid.attach (this._image, 0, 0, 2, 1);
            this._grid.attach (this._icon,  0, 1, 1, 1);
            this._grid.attach (this._label, 1, 1, 1, 1);
cs: 
            // Připojí obrázky a popisek do mřížky
            this._grid.attach (this._image, 0, 0, 2, 1);
            this._grid.attach (this._icon,  0, 1, 1, 1);
            this._grid.attach (this._label, 1, 1, 1, 1);

note: (itstool) path: section/p
en: That gives us this, when we run it:
cs: Po spuštění dostaneme něco takového:

note: (itstool) path: section/p
en: That's what the stock "About" icon looks like. You can see a list of all the stock items starting with gtk-about in <link href="https://developer.gnome.org/gtk3/3.4/gtk3-Stock-Items.html#GTK-STOCK-ABOUT:CAPS">GNOME's developer documentation</link>. It was written for C programmers, but you don't need to know C to use it; just look at the part in quotation marks, like "gtk-about", and copy that part to use the icon next to it.
cs: Je to to, co vypadá jako standardní ikona „O aplikaci“ (About). Na seznam všech standardních položek, počínaje gtk-about, se můžete podívat v <link href="https://developer.gnome.org/gtk3/3.4/gtk3-Stock-Items.html#GTK-STOCK-ABOUT:CAPS">dokumentaci pro vývojáře GNOME</link>. Byla napsána pro programátory v jazyce C, ale ten nepotřebujete znát k tomu, abyste ji mohli používat. Stačí se jen podívat na část v uvozovkách, jako je "gtk-about" a tuto část zkopírovat, když chcete použít ikonu vedle ní.

note: (itstool) path: note/p
en: We put single quotes around 'gtk-about' here because, unlike text strings that have double quotes around them, that part will never need to be translated into another language. In fact, if it <em>were</em> translated it'd break the icon, because its name is still "gtk-about" no matter which language you speak.
cs: Okolo 'gtk-about' jsem v kódu použili jednoduché uvozovky, protože na rozdíl od jiných textových řetězců, které máme v dvojitých uvozovkách, tento nebude nikdy potřeba překládat do jiného národního jazyka. Ve skutečnosti, kdyby <em>byl</em> přeložen, tak by došlo k porušení ikony, protože její název musí být pořád "gtk-about", bez ohledu na jazyk, ve kterém je uživatelské rozhraní.

note: (itstool) path: section/title
en: What's next?
cs: A co dál?

note: (itstool) path: section/p
en: Before we go on to the next tutorial, let's try something a little different:
cs: Než přikročíme k další lekci, zkusme něco udělat trochu jinak:

note: (itstool) path: section/code
en: 
            // Create a button
            this._button = new Gtk.Button ({
                label: "Welcome to GNOME, too!"});
    
            // Attach the images and button to the grid
            this._grid.attach (this._image,  0, 0, 2, 1);
            this._grid.attach (this._icon,   0, 1, 1, 1);
            this._grid.attach (this._button, 1, 1, 1, 1);
cs: 
            // Vytvoří tlačítko
            this._button = new Gtk.Button ({
                label: "Welcome to GNOME, too!"});
    
            // Připojí obrázky a tlačítka do mřížky
            this._grid.attach (this._image,  0, 0, 2, 1);
            this._grid.attach (this._icon,   0, 1, 1, 1);
            this._grid.attach (this._button, 1, 1, 1, 1);

note: (itstool) path: section/p
en: That's right, we turned the Label into a Button just by changing the name! If you run the application and click on it, though, you'll find that it doesn't do anything. How do we make our Button do something? That's what we'll find out, in <link xref="03_getting_the_signal.js">our next tutorial</link>.
cs: Je to pravda, změnili jsme popisek na tlačítko jen pouhou změnou názvu widgetu! Zjistíte však, že když aplikaci spustíte a kliknete na něj, nic nedělá. Jak jej přimět, aby něco dělalo? To je to, co se dozvíte v <link xref="03_getting_the_signal.js">naší následující lekci</link>.

note: (itstool) path: section/p
en: If you like, feel free to spend some time experimenting with Grids, Labels, and Images, including stock images.
cs: Jestli se vám to líbí, zkuste věnovat nějaký čas experimentování s mřížkami, popisky a obrázky, včetně standardních obrázků.

note: (itstool) path: note/p
en: One trick you can use to make more complex layouts is to nest Grids inside of each other. This lets you group together related widgets, and rearrange them easily. Take a look at the <link xref="radiobutton.js">RadioButton</link> code sample if you'd like to see how this is done.
cs: Jedním z triků, jak vytvořit složitější rozvržení, je vnoření mřížek do sebe. To umožňuje seskupit dohromady související widgety a snadno měnit jejich uspořádání. Pokud vás zajímá, jak se to dělá, podívejte na na ukázkový kód k widgetu <link xref="radiobutton.js">RadioButton</link>.

note: (itstool) path: section/title
en: Complete code sample
cs: Úplný kód ukázky

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    class WelcomeToTheGrid {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application();
    
        // Connect 'activate' and 'startup' signals to the callback functions
        this.application.connect('activate', this._onActivate.bind(this));
        this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI ();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 10,
                title: "Welcome to the Grid"});
    
            // Create the Grid
            this._grid = new Gtk.Grid ({
                // column_homogeneous: true,
                // column_spacing: 20,
                row_spacing: 20 });
    
            // Create an image
            this._image = new Gtk.Image ({ file: "gnome-image.png" });
    
            // Create a second image using a stock icon
            this._icon = new Gtk.Image ({ stock: 'gtk-about' });
    
            // Create a label
            this._label = new Gtk.Label ({
                label: "Welcome to GNOME, too!",
                /* margin_top: 20 */ });
    
            /* Create a second label
            this._labelTwo = new Gtk.Label ({
                label: "The cake is a pie." }); */
    
            /* Create a button
            this._button = new Gtk.Button ({
                label: "Welcome to GNOME, too!"}); */
    
            // Attach the images and button to the grid
            this._grid.attach (this._image,  0, 0, 2, 1);
            this._grid.attach (this._icon,   0, 1, 1, 1);
            this._grid.attach (this._label,  1, 1, 1, 1);
    
            // this._grid.attach (this._label, 0, 1, 1, 1);
            // this._grid.attach (this._labelTwo, 1, 1, 1, 1);
    
            // this._grid.attach (this._button, 1, 1, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
    };
    
    // Run the application
    let app = new WelcomeToTheGrid ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    class WelcomeToTheGrid {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application();
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
        this.application.connect('activate', this._onActivate.bind(this));
        this.application.connect('startup', this._onStartup.bind(this));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI ();
        },
    
    
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 10,
                title: "Welcome to the Grid"});
    
            // Vytvoří mřížku
            this._grid = new Gtk.Grid ({
                // column_homogeneous: true,
                // column_spacing: 20,
                row_spacing: 20 });
    
            // Vytvoří obrázek
            this._image = new Gtk.Image ({ file: "gnome-image.png" });
    
            // Vytvoří druhý obrázek pomocí standardní ikony
            this._icon = new Gtk.Image ({ stock: 'gtk-about' });
    
            // Vytvoří popisek
            this._label = new Gtk.Label ({
                label: "Welcome to GNOME, too!",
                /* margin_top: 20 */ });
    
            /* Vytvoří druhý popisek
            this._labelTwo = new Gtk.Label ({
                label: "The cake is a pie." }); */
    
            /* Vytvoří tlačítko
            this._button = new Gtk.Button ({
                label: "Welcome to GNOME, too!"}); */
    
            // Připojí obrázek a tlačítka do mřížky
            this._grid.attach (this._image,  0, 0, 2, 1);
            this._grid.attach (this._icon,   0, 1, 1, 1);
            this._grid.attach (this._label,  1, 1, 1, 1);
    
            // this._grid.attach (this._label, 0, 1, 1, 1);
            // this._grid.attach (this._labelTwo, 1, 1, 1, 1);
    
            // this._grid.attach (this._button, 1, 1, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
    };
    
    // Spustí aplikaci
    let app = new WelcomeToTheGrid ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: Create Buttons and other widgets that do things when you click on them.
cs: Vytvoříme tlačítka a další widgety, které budou něco dělat, když na ně klikneme.

note: (itstool) path: page/title
en: 3. Getting the Signal
cs: 3. Čekání na signál

note: (itstool) path: synopsis/p
en: In the last tutorial, we learned how to create widgets like Labels, Images, and Buttons. Here, we'll learn how to make Buttons and other input widgets actually do things, by writing functions which handle the signals they send when they are clicked on or interacted with.
cs: V této lekci se naučíme, jak vytvořit widgety, jako jsou popisky, obrázky a tlačítka. Naučíme se zde, jak přimět tlačítka a další vstupní widgety, aby dělali co po nich chceme, tím, že napíšeme funkce obsluhující signály, které widgety vyslaly při kliknutí nebo jiné interakce s nimi.

note: (itstool) path: section/title
en: A basic application
cs: Základní aplikace

note: (itstool) path: section/p
en: In GNOME, widgets that you can interact with, like Buttons and Switches, send out signals when they are clicked on or activated. A Button, for instance, sends out the "clicked" signal when somebody clicks on it. When this happens, GNOME looks for the part in your code that says what to do.
cs: V GNOME widgety, které komunikují s uživatelem, jako jsou tlačítka nebo vypínače, posílají při kliknutí nebo aktivaci signály. Například <code>Button </code> vyšle signál <code>"clicked"</code>, když na něj někdo klikne. Když se tak stane, GNOME se podívá po části kódu, která říká, co se má udělat.

note: (itstool) path: section/p
en: How do we write that code? By connecting that Button's "clicked" signal to a callback function, which is a function you write just to handle that signal. So whenever it gives off that signal, the function connected to that signal is run.
cs: Jak napsat takový kód? Napojením signálu <code>"clicked"</code> od tlačítka na funkci zpětného volání, což je funkce napsaná za účelem obsluhy takového signálu. Takže, když se objeví tento signál, je spuštěna funkce napojená na něj.

note: (itstool) path: section/p
en: Here is an extremely basic example:
cs: Zde je úplně základní příklad:

note: (itstool) path: section/p
en: This ApplicationWindow has a Button and a Label inside it, arranged in a Grid. Whenever the Button is clicked, a variable that holds the number of cookies is increased by 1, and the Label that shows how many cookies there are is updated.
cs: V ApplicationWindow jsou widgety Button a Label uspořádané v mřížce. Kdykoliv je kliknuto na tlačítko, zvýší se o 1 proměnná, která udržuje počet koláčků, a je aktualizován popisek, které zobrazuje počet koláčků.

note: (itstool) path: note/p
en: The cookies in this example are not the same as the cookies that you get from websites, which store your login information and may keep track of which sites you've visited. They're just imaginary treats. You may bake some real ones if you like.
cs: Koláčky (anglicky „cookies“) jsou v tomto kódu něco jiného, než „cookies“, které znáte z webů. Tam se do nich ukládají přihlašovací informace, pamatuje se v nich, jestli jste web již navštívili apod. V našem případě prostě představují imaginární koláčky. Ale jestli chcete, můžete si upéct nějaké opravdové.

note: (itstool) path: section/p
en: Here is the basic, boilerplate code that goes at the start of the application, before we start creating the window and widgets. Besides the application having a unique name, the biggest change from the usual boilerplate is that we create a global variable right near the beginning, to hold the number of cookies.
cs: Zde je základní, často používaný kód, který patří na začátek aplikace, ještě než začnete vytvářet okno a widgety. Kromě toho, že aplikace musí mít jedinečný název, je největší změnou oproti běžnému základnímu kódu vytvoření globální proměnné na začátku, ve které budeme udržovat počet koláčků.

note: (itstool) path: section/code
en: 
    #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // We start out with 0 cookies
    var cookies = 0;
    
    class GettingTheSignal {
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application();
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI ();
        }
cs: 
    #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // Začneme s 0 koláčky
    var cookies = 0;
    
    class GettingTheSignal {
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application();
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }

note: (itstool) path: section/p
en: Take a look at the part that uses our application's connect method and bind, to connect its activate and startup signals to the functions that present the window and build the UI. We're going to do the same thing with our Button when we get to it, except that we're going to connect its "clicked" signal instead.
cs: Podívejte se na část, která používá metodu <code>connect</code> naší aplikace a <code>bind</code> k připojení jejích signálů <code>"activate"</code> a <code>"startup"</code> na funkce, které představují okno a sestaví uživatelské rozhraní. To stejné se chystáme udělat s naším tlačítkem, až jej budeme mít, akorát napojovaný signál bude tentokrát <code>"clicked"</code>.

note: (itstool) path: section/title
en: Click the button
cs: Kliknutí na tlačítko

note: (itstool) path: section/p
en: As usual, we'll put all the code to create our Button and other widgets inside the _buildUI function, which is called when the application starts up.
cs: Jako obvykle, vložíme celý kód pro vytvoření tlačítka a ostatních widgetů do funkce <code>_buildUI</code>, která je volána, když se aplikace spouští.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI() {
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {

note: (itstool) path: section/p
en: First, we create the window itself:
cs: Nejprve vytvoříme vlastní okno:

note: (itstool) path: section/code
en: 
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                title: "Click the button to get a cookie!"});
cs: 
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                title: "Click the button to get a cookie!"});

note: (itstool) path: section/p
en: Note that we've set its default_height and default_width properties. These let us control how tall and wide the ApplicationWindow will be, in pixels.
cs: Všimněte si, že jsem nastavili vlastnosti <code>default_height</code> a <code>default_width</code>. Ty nám umožňují určit v pixelech, jak vysoké a široké bude okno ApplicationWindow.

note: (itstool) path: section/p
en: Next, we'll create the Label that shows us the number of cookies. We can use the cookies variable as part of the Label's label property.
cs: Následně vytvoříme popisek, který bude zobrazovat počet koláčků. Můžeme použít proměnnou <var>cookies</var> jako součást vlastnosti <code>label</code> popisku.

note: (itstool) path: section/code
en: 
            // Create the label
            this._cookieLabel = new Gtk.Label ({
                label: "Number of cookies: " + cookies });
cs: 
            // Vytvoří popisek
            this._cookieLabel = new Gtk.Label ({
                label: "Number of cookies: " + cookies });

note: (itstool) path: section/p
en: Now we'll create the Button. We set its label property to show the text that we want on the Button, and we connect its "clicked" signal to a function called _getACookie, which we'll write after we're done building our application's UI.
cs: Nyní se pustíme do vytvoření widgetu <code>Button</code>. Nastavíme jeho vlastnost <code>label</code>, která zobrazuje text, který chceme na tlačítku, a napojíme jeho signál <code>"clicked"</code> na funkci zpětného volání <code>_getACookie</code>, kterou napíšeme později, až dokončíme konstrukci uživatelského rozhraní naší aplikace.

note: (itstool) path: section/code
en: 
            // Create the cookie button
            this._cookieButton = new Gtk.Button ({ label: "Get a cookie" });
    
            // Connect the cookie button to the function that handles clicking it
            this._cookieButton.connect ('clicked', this._getACookie.bind(this));
cs: 
            // Vytvoří tlačítko na koláčky
            this._cookieButton = new Gtk.Button ({ label: "Get a cookie" });
    
            // Napojí tlačítko na koláčky k funkci, která zpracovává jeho kliknutí
            this._cookieButton.connect ('clicked', this._getACookie.bind(this));

note: (itstool) path: section/p
en: Finally, we create a Grid, attach the Label and Button to it, add it to the window and tell the window to show itself and its contents. That's all we need inside the _buildUI function, so we close it with a bracket, as well as a comma that tells GNOME to go on to the next function. Note that even though we wrote the code for the Label first, we can still attach it to the Grid in a way that will put it on the bottom.
cs: Nakonec vytvoříme mřížku, připojíme do ní popisek a tlačítko, přidáme ji do okna a oknu řekneme, ať zobrazí sebe a všechen svůj obsah. To vše potřebujeme uvnitř funkce <code>_buildUI</code>, takže ji uzavřeme složenými závorkami a za ně dáme čárku, která GNOME říká, že následuje další funkce. Všimněte si, že ačkoliv jsme napsali kód pro popisek jako první, stále jej můžete připojit do mřížky způsobem, který jej umístí dolů.

note: (itstool) path: section/code
en: 
            // Create a grid to arrange everything inside
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                row_spacing: 20 });
    
            // Put everything inside the grid
            this._grid.attach (this._cookieButton, 0, 0, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 1, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
    
        }
cs: 
            // Vytvoří mřížku, do které se vše uspořádá
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                row_spacing: 20 });
    
            // Vloží vše do mřížky
            this._grid.attach (this._cookieButton, 0, 0, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 1, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
    
        }

note: (itstool) path: section/p
en: Now, we write the _getACookie function. Whenever our Button sends out its "clicked" signal, the code in this function will run. In this case, all it does is increase the number of cookies by 1, and update the Label to show the new number of cookies. We do this using the Label's set_label method.
cs: Nyní napíšeme funkci <code>_getACookie</code>. Kdykoliv naše tlačítko pošle signál <code>"clicked"</code>, spustí se kód v této funkci. V tomto případě je vše, co udělá, že zvýší počet koláčků o 1 a zaktualizuje popisek, aby zobrazoval nový počet koláčků. To uděláme pomocí metody <code>set_label</code> widgetu <code>Label</code>.

note: (itstool) path: note/p
en: Many widgets have the same properties and methods. Both Labels and Buttons, for instance, have a label property that says what text is inside them, and get_label and set_label methods that let you check what that text is and change it, respectively. So if you learn how one widget works, you'll also know how others like it work.
cs: Mnoho widgetů má stejné vlastnosti a metody. Například jak Label, tak Button má vlastnost <code>label</code>, která říká, jaký je v nich text, a metody <code>get_label</code> a <code>set_label</code>, které umožňují zkontrolovat, co je to za text a případně jej změnit. Takže, když se učíte, jak nějaký widget funguje, zároveň se to učíte i o ostatních podobných.

note: (itstool) path: section/code
en: 
        _getACookie: function() {
    
            // Increase the number of cookies by 1 and update the label
            cookies++;
            this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
        }
    
    };
cs: 
        _getACookie: function() {
    
            // Zvýší počet koláčků o 1 a aktualizuje popisek
            cookies++;
            this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
        }
    
    };

note: (itstool) path: section/p
en: Finally, we run the application, using the same kind of code as in our last tutorial.
cs: Nakonec spustíme aplikaci pomocí stejného druhu kódu, jako v poslední lekci.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new GettingTheSignal ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new GettingTheSignal ();
    app.application.run (ARGV);

note: (itstool) path: section/title
en: Flip the switch
cs: Přepnutí vypínače

note: (itstool) path: section/p
en: Buttons aren't the only input widgets in our GTK+ toolbox. We can also use switches, like the one in this example. Switches don't have a label property, so we have to create a separate Label that says what it does to go next to it.
cs: Tlačítka nejsou jediné vstupní widgety v nástrojové sadě GTK+. Můžeme používat například také vypínače, jako v tomto příkladu. <code>Swith</code> nemá vlastnost <code>label</code>, takže musíme zvlášť vytvořit popisek vysvětlující, co dělá vypínač vedle něj.

note: (itstool) path: section/p
en: A Switch has two positions, Off and On. When a Switch is turned on, its text and background color change, so you can tell which position it's in.
cs: Vypínač má dvě polohy, vypnuto a zapnuto. Kdy je vypínač zapnutý, jeho text a barva pozadí se změní, takže poznáte, ve které poloze je.

note: (itstool) path: section/p
en: You may have seen Switches like these in GNOME's accessibility menu, which let you turn features like large text and the on-screen keyboard on and off. In this case, the Switch controls our imaginary cookie dispenser. If the Switch is turned on, you can get cookies by clicking the "Get a cookie" Button. If it's turned off, clicking the Button won't do anything.
cs: Stejné vypínače jako zde můžete vidět například v nabídce zpřístupnění GNOME, kde zapínají a vypínají funkce, jako je velký text a klávesnice na obrazovce. V našem případě <code>Switch</code> řídí smyšlený automat na koláčky. Když je vypínač zapnutý, můžete dostat koláček kliknutím na tlačítko <gui>Get a cookie</gui>. Když je vypnutý, neděje se při kliknutí na tlačítko nic.

note: (itstool) path: note/p
en: You can get to the accessibility menu by clicking on the outline of a human, near your name in the upper-right corner of the screen.
cs: Do nabídky zpřístupnění se můžete dostat kliknutím na obrys postavičky mezi ikonami v pravém horním rohu obrazovky.

note: (itstool) path: section/p
en: Here's how we create the Switch:
cs: Zde vytvoříme widget Switch:

note: (itstool) path: section/code
en: 
            // Create the switch that controls whether or not you can win
            this._cookieSwitch = new Gtk.Switch ();
cs: 
            // Vytvoří vypínač
            this._cookieSwitch = new Gtk.Switch ();

note: (itstool) path: section/p
en: We don't actually need to connect the Switch to anything. All we need to do is write an if statement in our _getACookie function, to check to see if the Switch is turned on. If we wanted to make something happen as soon as you flip the Switch, though, we would connect its notify::active signal, like so:
cs: Z praktického hlediska nepotřebujeme vypínač napojovat na žádnou funkci. Vše co potřebujeme, je napsat podmínku v naší funkci _getACookie, která kontroluje, jestli je vypínač zapnutý nebo vypnutý. Pokud byste však chtěli, aby se něco stalo hned, jak vypínač přepnete, napojili byste jej na signál <code>"notify::active"</code> nějak takto:

note: (itstool) path: section/code
en: 
            // Connect the switch to the function that handles it
            this._cookieSwitch.connect ('notify::active', this._cookieDispenser.bind(this));
cs: 
            // Napojí vypínač k funkci, která jej obsluhuje
            this._cookieSwitch.connect ('notify::active', this._cookieDispenser.bind(this));

note: (itstool) path: section/p
en: A Switch is set to the off position by default. If we wanted the Switch to start out turned on, we would set the value of its active property to true when we create it.
cs: Ve výchozím stavu je vypínač v poloze vypnuto. Pokud jej chceme na začátku mít v poloze zapnuto, nastavili bychom při jeho vytváření hodnotu jeho vlastnosti <code>active</code> na <code>true</code>.

note: (itstool) path: section/p
en: Let's just create it normally, though, and then create the Label that goes with it. We want the Switch and the Label to be kept right next to each other, so we'll create a Grid just for them, then put that Grid in our larger Grid that holds all the widgets inside it. Here's what the code looks like to create all that:
cs: Pojďme ho ale vytvořit normálně a k němu vytvoříme i popisek. Chceme, aby vypínač i popisek byly umístěny správně vedle sebe, takže pro ně vytvoříme mřížku a tu vložíme do naší větší mřížky, která má v sobě ostatní widgety. Zde máte, jak vypadá kód, který toto vše vytvoří:

note: (itstool) path: section/code
en: 
            // Create the switch that controls whether or not you can win
            this._cookieSwitch = new Gtk.Switch ();
    
            // Create the label to go with the switch
            this._switchLabel = new Gtk.Label ({
                label: "Cookie dispenser" });
    
            // Create a grid for the switch and its label
            this._switchGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Put the switch and its label inside that grid
            this._switchGrid.attach (this._switchLabel, 0, 0, 1, 1);
            this._switchGrid.attach (this._cookieSwitch, 1, 0, 1, 1);
cs: 
            // Vytvoří vypínač, který řídí, jestli můžete vyhrát nebo ne
            this._cookieSwitch = new Gtk.Switch ();
    
            // Vytvoří popisek, který se řídí podle vypínače
            this._switchLabel = new Gtk.Label ({
                label: "Cookie dispenser" });
    
            // Vytvoří mřížku pro vypínač a jeho popisek
            this._switchGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Vloží vypínač a jeho popisek do mřížky
            this._switchGrid.attach (this._switchLabel, 0, 0, 1, 1);
            this._switchGrid.attach (this._cookieSwitch, 1, 0, 1, 1);

note: (itstool) path: section/p
en: And now we arrange everything in the larger Grid like so.
cs: A nyní obdobně vše uspořádáme ve větší mřížce.

note: (itstool) path: section/code
en: 
            // Put everything inside the grid
            this._grid.attach (this._cookieButton, 0, 0, 1, 1);
            this._grid.attach (this._switchGrid, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);
cs: 
            // Vše se vloží do mřížky
            this._grid.attach (this._cookieButton, 0, 0, 1, 1);
            this._grid.attach (this._switchGrid, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);

note: (itstool) path: section/p
en: Now we change the _getACookie function so that it checks to see if the cookie dispenser is turned on. We do that by using the Switch's get_active method. It returns true if the Switch is turned on, and false if the Switch is turned off.
cs: Nyní změníme funkci _getACookie tak, aby se dívala, jestli je automat na koláčky zapnutý. Uděláme to pomocí metody přepínače <code>get_active</code>. Ta vrací <code>true</code>, když je vypínač zapnutý a <code>false</code>, když je vypínač vypnutý.

note: (itstool) path: note/p
en: When a method is used in an if statement like this, the code inside the if statement is executed if the method returns true.
cs: Když je metoda použita v podmíněném výrazu <code>if</code> jako zde, je kód uvnitř výrazu proveden, pokud metoda vrátí <code>true</code>.

note: (itstool) path: section/code
en: 
        _getACookie() {
    
            // Is the cookie dispenser turned on?
            if (this._cookieSwitch.get_active()) {
    
                // Increase the number of cookies by 1 and update the label
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }
cs: 
        _getACookie() {
    
            // Je automat na koláčky zapnutý?
            if (this._cookieSwitch.get_active()) {
    
                // Zvýší počet koláčků o 1 a aktualizuje popisek
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }

note: (itstool) path: section/title
en: Tuning the radio
cs: Ladění rádia

note: (itstool) path: section/p
en: Another type of input widget we can use is called the RadioButton. You create them in groups, and then only one RadioButton in a group can be selected at a time. They're called RadioButtons because they work like the channel preset button in old-style car radios. The radio could only be tuned to one station at a time, so whenever you pressed one button in, another would pop back out.
cs: Jiný typ vstupního widgetu, který můžeme použít, se nazývá <code>RadioButton</code> (skupinový přepínač). Vytváří se ve skupinách a jen jeden z nich pak může být v kterýkoliv okamžik vybrán. Anglicky se nazývá „rádiové tlačítko“, protože funguje podobně jako volič kanálů na starých autorádiích. Rádio může mít v jeden okamžik naladěnu jen jednu stanici, takže když jste zmáčkli kterékoliv tlačítko, všechny ostatní vyskočily.

note: (itstool) path: section/p
en: First off, let's change our ApplicationWindow's name and increase its border_width property, so that our widgets aren't packed in too tightly. The border_width is the number of pixels between any widget and the edge of the window.
cs: Nejdříve ze všeho pojďme změnit název našeho <code>ApplicationWindow</code> a zvětšit jeho vlastnost <code>border_width</code>, aby v něm naše widgety nebyly příliš namačkané. Vlastnost <code>border_width</code> udává počet pixelů mezi widgetem a hranou okna.

note: (itstool) path: section/code
en: 
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                border_width: 20,
                title: "Choose the one that says 'cookie'!"});
cs: 
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                border_width: 20,
                title: "Choose the one that says 'cookie'!"});

note: (itstool) path: section/p
en: After that, we create the RadioButtons. Remember how they're created in groups? The way we do that, is we set each new RadioButton's group property to the name of another RadioButton.
cs: Po té vytvoříme skupinové přepínače. Pamatujete si, že jsou vytvořené ve skupině? Způsob, jak to udělat, je že u každého nového skupinového přepínače nastavíme vlastnost <code>group</code> na název jiného skupinového přepínače.

note: (itstool) path: section/code
en: 
            // Create the radio buttons
            this._cookieRadio = new Gtk.RadioButton ({ label: "Cookie" });
            this._notCookieOne = new Gtk.RadioButton ({ label: "Not cookie",
                group: this._cookieRadio });
            this._notCookieTwo = new Gtk.RadioButton ({ label: "Not cookie",
                group: this._cookieRadio });
cs: 
            // Vytvoří skupinové přepínače
            this._cookieRadio = new Gtk.RadioButton ({ label: "Cookie" });
            this._notCookieOne = new Gtk.RadioButton ({ label: "Not cookie",
                group: this._cookieRadio });
            this._notCookieTwo = new Gtk.RadioButton ({ label: "Not cookie",
                group: this._cookieRadio });

note: (itstool) path: section/p
en: Next, we create a Grid for the RadioButtons. Remember, we don't have to arrange things in Grids in the same order that we create them in.
cs: Následně vytvoříme mřížku pro skupinové přepínače. Pamatujte, že widgety nemusíte do mřížky uspořádat ve stejném pořadí, v jakém jste je vytvořili.

note: (itstool) path: section/code
en: 
            // Arrange the radio buttons in their own grid
            this._radioGrid = new Gtk.Grid ();
            this._radioGrid.attach (this._notCookieOne, 0, 0, 1, 1);
            this._radioGrid.attach (this._cookieRadio, 0, 1, 1, 1);
            this._radioGrid.attach (this._notCookieTwo, 0, 2, 1, 1);
cs: 
            // Uspořádá skupinové přepínače do jejich vlastní mřížky
            this._radioGrid = new Gtk.Grid ();
            this._radioGrid.attach (this._notCookieOne, 0, 0, 1, 1);
            this._radioGrid.attach (this._cookieRadio, 0, 1, 1, 1);
            this._radioGrid.attach (this._notCookieTwo, 0, 2, 1, 1);

note: (itstool) path: section/p
en: Normally, the RadioButton that's selected by default is the one that's the name of the group. We want the first "Not cookie" button to be selected by default, though, so we use its set_active method.
cs: Normálně je ve výchozím stavu vybrán ten skupinový přepínač, který má název skupiny. My ale chceme, aby byl ve výchozím stavu vybrán první skupinový přepínač „Not cookie“, takže použijeme metodu <code>set_active</code>.

note: (itstool) path: note/p
en: We could also set its active property to true when we create it.
cs: Jeho vlastnost <code>active</code> můžeme nastavit na <code>true</code> také při jeho vytváření.

note: (itstool) path: section/code
en: 
            // Set the button that will be at the top to be active by default
            this._notCookieOne.set_active (true);
cs: 
            // Nastaví, že skupinový přepínač, které bude nahoře, bude ve
            // výchozím stavu aktivní
            this._notCookieOne.set_active (true);

note: (itstool) path: section/p
en: Now we arrange everything in our main Grid like usual ...
cs: Nyní vše jako obvykle uspořádáme v naší hlavní mřížce…

note: (itstool) path: section/code
en: 
            // Put everything inside the grid
            this._grid.attach (this._radioGrid, 0, 0, 1, 1);
            this._grid.attach (this._cookieButton, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);
cs: 
            // Vloží vše do mřížky
            this._grid.attach (this._radioGrid, 0, 0, 1, 1);
            this._grid.attach (this._cookieButton, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);

note: (itstool) path: section/p
en: And then we change our _getACookie function to test to see if the cookie button is the one that's selected.
cs: A pak změníme naši funkci <code>_getACookie</code>, aby testovala, jestli je je vybrán přepínač s koláčkem.

note: (itstool) path: section/code
en: 
        _getACookie() {
    
            // Did you select "cookie" instead of "not cookie"?
            if (this._cookieRadio.get_active()) {
    
                // Increase the number of cookies by 1 and update the label
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }
cs: 
        _getACookie() {
    
            // Vybrali jste „cookie“ místo „not cookie“?
            if (this._cookieRadio.get_active()) {
    
                // Zvýší počet koláčků o 1 a aktualizuje popisek
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }

note: (itstool) path: section/title
en: Can you spell "cookie"?
cs: Umíte hláskovat „cookie“?

note: (itstool) path: section/p
en: The last input widget we're going to cover is the Entry widget, which is used for single-line text entry.
cs: Posledním vstupním widgetem, kterým se budeme zabývat, je <code>Entry</code> (vstupní pole), který se používá jako jednořádkové vstupní pole.

note: (itstool) path: note/p
en: If you need to be able to enter in a whole paragraph or more, like if you are building a text editor, you'll want to look at the much more customizable <link xref="textview.js">TextView</link> widget.
cs: Pokud potřebujete mít možnost zadat celý odstavec nebo i více, třeba když tvoříte textový editor, měli byste se podívat po více přizpůsobitelném widgetu <link xref="textview.js">TextView</link>.

note: (itstool) path: section/p
en: After we change the window's name, we create the Entry widget.
cs: Po té, co změníme název okna, vytvoříme widget <code>Entry</code>.

note: (itstool) path: section/code
en: 
            // Create the text entry field
            this._spellCookie = new Gtk.Entry ();
cs: 
            // Vytvoří textové vstupní pole
            this._spellCookie = new Gtk.Entry ();

note: (itstool) path: section/p
en: Next, we arrange everything in the Grid ...
cs: Následně vše uspořádáme do mřížky…

note: (itstool) path: section/code
en: 
            // Put everything inside the grid
            this._grid.attach (this._spellCookie, 0, 0, 1, 1);
            this._grid.attach (this._cookieButton, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);
cs: 
            // Vloží vše do mřížky
            this._grid.attach (this._spellCookie, 0, 0, 1, 1);
            this._grid.attach (this._cookieButton, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);

note: (itstool) path: section/p
en: And now we modify _getACookie's if statement again, using the Entry's get_text method to retrieve the text that you entered into it and see if you spelled "cookie" right. We don't care whether you capitalize "cookie" or not, so we use JavaScript's built-in toLowerCase method to change the Entry's text to all lower case inside the if statement.
cs: A nyní opět změníme podmíněný výraz ve funkci <code>_getACookie</code> a to s pomocí metody <code>get_text</code>, která získává text, který byl zadán, takže můžeme zkontrolovat, jestli „cookie“ bylo správně hláskováno. Přitom se nechceme starat o velikost písmen, takže použijeme vestavěnou metodu jazyka JavaScript <code>toLowerCase</code>, která v podmíněném výrazu změní zadaný text na malá písmena.

note: (itstool) path: note/p
en: An Entry widget doesn't have a label property, which is a set text string that the user can't change. (You can't normally change the label on a Button, for instance.) Instead, it has a text property, which changes to match what the user types in.
cs: Widget <code>Entry</code> nemá vlastnost <code>label</code>, která by nastavovala textový řetězec, který uživatel nemůže měnit (podobně, jako například normálně nemůžete měnit text na widgetu tlačítko). Má ale vlastnost <code>text</code>, která mění to, co uživatel píše.

note: (itstool) path: section/code
en: 
        _getACookie() {
    
            // Did you spell "cookie" correctly?
            if ((this._spellCookie.get_text()).toLowerCase() == "cookie") {
    
                // Increase the number of cookies by 1 and update the label
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }
cs: 
        _getACookie() {
    
            // Vyhláskovali jste „cookie“ správně?
            if ((this._spellCookie.get_text()).toLowerCase() == "cookie") {
    
                // Zvýší počet koláčků o 1 a aktualizuje popisek
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }

note: (itstool) path: section/p
en: Keep reading, if you'd like to see the complete code for each version of our cookie maker application.
cs: Jestli chcete vidět celý kód pro každou z verzí aplikace produkující koláčky, čtěte dál.

note: (itstool) path: note/p
en: The main JavaScript tutorials page has <link xref="beginner.js#buttons">more detailed code samples</link> for each input widget, including several not covered here.
cs: Hlavní stránka s výukou jazyka JavaScript má <link xref="beginner.js#buttons">podrobnější ukázky kódu</link> pro každý jednotlivý widget, včetně několika, které zde rozebrané nejsou.

note: (itstool) path: section/title
en: Complete code samples
cs: Celý kód ukázky

note: (itstool) path: section/title
en: Code sample with Button
cs: Ukázkový kód s widgetem Button

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // We start out with 0 cookies
    var cookies = 0;
    
    class GettingTheSignal {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application();
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                title: "Click the button to get a cookie!"});
    
            // Create the label
            this._cookieLabel = new Gtk.Label ({
                label: "Number of cookies: " + cookies });
    
            // Create the cookie button
            this._cookieButton = new Gtk.Button ({ label: "Get a cookie" });
    
            // Connect the cookie button to the function that handles clicking it
            this._cookieButton.connect ('clicked', this._getACookie.bind(this));
    
            // Create a grid to arrange everything inside
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                row_spacing: 20 });
    
            // Put everything inside the grid
            this._grid.attach (this._cookieButton, 0, 0, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 1, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
    
        }
    
        _getACookie() {
    
            // Increase the number of cookies by 1 and update the label
            cookies++;
            this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
        }
    
    };
    
    // Run the application
    let app = new GettingTheSignal ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // Začneme s 0 koláčky
    var cookies = 0;
    
    class GettingTheSignal {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application();
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                title: "Click the button to get a cookie!"});
    
            // Vytvoří popisek
            this._cookieLabel = new Gtk.Label ({
                label: "Number of cookies: " + cookies });
    
            // Vytvoří tlačítko na koláčky
            this._cookieButton = new Gtk.Button ({ label: "Get a cookie" });
    
            // Připojí tlačítko na koláčky k funkci, která zpracovává jeho kliknutí
            this._cookieButton.connect ('clicked', this._getACookie.bind(this));
    
            // Vytvoří mřížku, do které se vše uspořádá
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                row_spacing: 20 });
    
            // Vloží vše do mřížky
            this._grid.attach (this._cookieButton, 0, 0, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 1, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
    
        }
    
        _getACookie() {
    
            // Zvýší počet koláčků o 1 a aktualizuje popisek
            cookies++;
            this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
        }
    
    };
    
    // Spustí aplikaci
    let app = new GettingTheSignal ();
    app.application.run (ARGV);

note: (itstool) path: section/title
en: Code sample with Switch
cs: Ukázkový kód s widgetem Switch

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // We start out with 0 cookies
    var cookies = 0;
    
    class GettingTheSignal {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application();
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                title: "Click the button to get a cookie!"});
    
            // Create the label
            this._cookieLabel = new Gtk.Label ({
                label: "Number of cookies: " + cookies });
    
            // Create the cookie button
            this._cookieButton = new Gtk.Button ({
                label: "Get a cookie" });
    
            // Connect the cookie button to the function that handles clicking it
            this._cookieButton.connect ('clicked', this._getACookie.bind(this));
    
            // Create the switch that controls whether or not you can win
            this._cookieSwitch = new Gtk.Switch ();
    
            // Create the label to go with the switch
            this._switchLabel = new Gtk.Label ({
                label: "Cookie dispenser" });
    
            // Create a grid for the switch and its label
            this._switchGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Put the switch and its label inside that grid
            this._switchGrid.attach (this._switchLabel, 0, 0, 1, 1);
            this._switchGrid.attach (this._cookieSwitch, 1, 0, 1, 1);
    
            // Create a grid to arrange everything else inside
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                row_spacing: 20 });
    
            // Put everything inside the grid
            this._grid.attach (this._cookieButton, 0, 0, 1, 1);
            this._grid.attach (this._switchGrid, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
    
        }
    
        _getACookie() {
    
            // Is the cookie dispenser turned on?
            if (this._cookieSwitch.get_active()) {
    
                // Increase the number of cookies by 1 and update the label
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }
    
    };
    
    // Run the application
    let app = new GettingTheSignal ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // Začneme s 0 koláčky
    var cookies = 0;
    
    class GettingTheSignal {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application();
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                title: "Click the button to get a cookie!"});
    
            // Vytvoří popisek
            this._cookieLabel = new Gtk.Label ({
                label: "Number of cookies: " + cookies });
    
            //  Vytvoří tlačítko na koláčky
            this._cookieButton = new Gtk.Button ({
                label: "Get a cookie" });
    
            // Připojí tlačítko na koláčky k funkci, která zpracovává jeho kliknutí
            this._cookieButton.connect ('clicked', this._getACookie.bind(this));
    
            // Vytvoří vypínač, který řídí, jestli můžete vyhrát nebo ne
            this._cookieSwitch = new Gtk.Switch ();
    
            // Vytvoří popisek, který se řídí podle vypínače
            this._switchLabel = new Gtk.Label ({
                label: "Cookie dispenser" });
    
            // Vytvoří mřížku pro vypínač a jeho popisek
            this._switchGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Vloží vypínač a jeho popisek do mřížky
            this._switchGrid.attach (this._switchLabel, 0, 0, 1, 1);
            this._switchGrid.attach (this._cookieSwitch, 1, 0, 1, 1);
    
            // Vytvoří mřížku, do které se vše uspořádá
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                row_spacing: 20 });
    
            // Vše se vloží do mřížky
            this._grid.attach (this._cookieButton, 0, 0, 1, 1);
            this._grid.attach (this._switchGrid, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
    
        }
    
        _getACookie() {
    
            // Je automat na koláčky zapnutý?
            if (this._cookieSwitch.get_active()) {
    
                // Zvýší počet koláčků o 1 a aktualizuje popisek
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }
    
    };
    
    // Spustí aplikaci
    let app = new GettingTheSignal ();
    app.application.run (ARGV);

note: (itstool) path: section/title
en: Code sample with RadioButton
cs: Ukázkový kód s widgetem RadioButton

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // We start out with 0 cookies
    var cookies = 0;
    
    class GettingTheSignal {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application();
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                border_width: 20,
                title: "Choose the one that says 'cookie'!"});
    
            // Create the radio buttons
            this._cookieRadio = new Gtk.RadioButton ({ label: "Cookie" });
            this._notCookieOne = new Gtk.RadioButton ({ label: "Not cookie",
                group: this._cookieRadio });
            this._notCookieTwo = new Gtk.RadioButton ({ label: "Not cookie",
                group: this._cookieRadio });
    
            // Arrange the radio buttons in their own grid
            this._radioGrid = new Gtk.Grid ();
            this._radioGrid.attach (this._notCookieOne, 0, 0, 1, 1);
            this._radioGrid.attach (this._cookieRadio, 0, 1, 1, 1);
            this._radioGrid.attach (this._notCookieTwo, 0, 2, 1, 1);
    
            // Set the button that will be at the top to be active by default
            this._notCookieOne.set_active (true);
    
            // Create the cookie button
            this._cookieButton = new Gtk.Button ({
                label: "Get a cookie" });
    
            // Connect the cookie button to the function that handles clicking it
            this._cookieButton.connect ('clicked', this._getACookie.bind(this));
    
            // Create the label
            this._cookieLabel = new Gtk.Label ({
                label: "Number of cookies: " + cookies });
    
            // Create a grid to arrange everything inside
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                row_spacing: 20 });
    
            // Put everything inside the grid
            this._grid.attach (this._radioGrid, 0, 0, 1, 1);
            this._grid.attach (this._cookieButton, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
    
        }
    
        _getACookie() {
    
            // Did you select "cookie" instead of "not cookie"?
            if (this._cookieRadio.get_active()) {
    
                // Increase the number of cookies by 1 and update the label
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }
    
    };
    
    // Run the application
    let app = new GettingTheSignal ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // Začneme s 0 koláčky
    var cookies = 0;
    
    class GettingTheSignal {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application();
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                border_width: 20,
                title: "Choose the one that says 'cookie'!"});
    
            // Vytvoří skupinové přepínače
            this._cookieRadio = new Gtk.RadioButton ({ label: "Cookie" });
            this._notCookieOne = new Gtk.RadioButton ({ label: "Not cookie",
                group: this._cookieRadio });
            this._notCookieTwo = new Gtk.RadioButton ({ label: "Not cookie",
                group: this._cookieRadio });
    
            // Uspořádá skupinové přepínače do jejich vlastní mřížky
            this._radioGrid = new Gtk.Grid ();
            this._radioGrid.attach (this._notCookieOne, 0, 0, 1, 1);
            this._radioGrid.attach (this._cookieRadio, 0, 1, 1, 1);
            this._radioGrid.attach (this._notCookieTwo, 0, 2, 1, 1);
    
            // Nastaví, že skupinový přepínač, které bude nahoře, bude ve
            this._notCookieOne.set_active (true);
    
            // Vytvoří tlačítko na koláčky
            this._cookieButton = new Gtk.Button ({
                label: "Get a cookie" });
    
            // Napojí tlačítko na koláčky k funkci, která zpracovává jeho kliknutí
            this._cookieButton.connect ('clicked', this._getACookie.bind(this));
    
            // Vytvoří popisek
            this._cookieLabel = new Gtk.Label ({
                label: "Number of cookies: " + cookies });
    
            // Vytvoří mřížku, do které se vše uspořádá
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                row_spacing: 20 });
    
            // Vloží vše do mřížky
            this._grid.attach (this._radioGrid, 0, 0, 1, 1);
            this._grid.attach (this._cookieButton, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
    
        }
    
        _getACookie() {
    
            // Vybrali jste „cookie“ místo „not cookie“?
            if (this._cookieRadio.get_active()) {
    
                // Zvýší počet koláčků o 1 a aktualizuje popisek
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }
    
    };
    
    // Spustí aplikaci
    let app = new GettingTheSignal ();
    app.application.run (ARGV);

note: (itstool) path: section/title
en: Code sample with Entry
cs: Ukázkový kód s widgetem Entry

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // We start out with 0 cookies
    var cookies = 0;
    
    class GettingTheSignal {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application();
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                border_width: 20,
                title: "Spell 'cookie' to get a cookie!"});
    
            // Create the text entry field
            this._spellCookie = new Gtk.Entry ();
    
            // Create the cookie button
            this._cookieButton = new Gtk.Button ({
                label: "Get a cookie" });
    
            // Connect the cookie button to the function that handles clicking it
            this._cookieButton.connect ('clicked', this._getACookie.bind(this));
    
            // Create the label
            this._cookieLabel = new Gtk.Label ({
                label: "Number of cookies: " + cookies });
    
            // Create a grid to arrange everything inside
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                row_spacing: 20 });
    
            // Put everything inside the grid
            this._grid.attach (this._spellCookie, 0, 0, 1, 1);
            this._grid.attach (this._cookieButton, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
    
        }
    
        _getACookie() {
    
            // Did you spell "cookie" correctly?
            if ((this._spellCookie.get_text()).toLowerCase() == "cookie") {
    
                // Increase the number of cookies by 1 and update the label
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }
    
    };
    
    // Run the application
    let app = new GettingTheSignal ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // Začneme s 0 koláčky
    var cookies = 0;
    
    class GettingTheSignal {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application();
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 200,
                default_width: 400,
                border_width: 20,
                title: "Spell 'cookie' to get a cookie!"});
    
            // Vytvoří textové vstupní pole
            this._spellCookie = new Gtk.Entry ();
    
            // Vytvoří tlačítko na koláčky
            this._cookieButton = new Gtk.Button ({
                label: "Get a cookie" });
    
            // Napojí tlačítko na koláčky k funkci, která zpracovává jeho kliknutí
            this._cookieButton.connect ('clicked', Lang.bind (this, this._getACookie));
    
            // Vytvoří popisek
            this._cookieLabel = new Gtk.Label ({
                label: "Number of cookies: " + cookies });
    
            // Vytvoří mřížku, do které se vše uspořádá
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                row_spacing: 20 });
    
            // Vloží vše do mřížky
            this._grid.attach (this._spellCookie, 0, 0, 1, 1);
            this._grid.attach (this._cookieButton, 0, 1, 1, 1);
            this._grid.attach (this._cookieLabel, 0, 2, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
    
        }
    
        _getACookie() {
    
            // Vyhláskovali jste „cookie“ správně?
            if ((this._spellCookie.get_text()).toLowerCase() == "cookie") {
    
                // Zvýší počet koláčků o 1 a aktualizuje popisek
                cookies++;
                this._cookieLabel.set_label ("Number of cookies: " + cookies);
    
            }
    
        }
    
    };
    
    // Spustí aplikaci
    let app = new GettingTheSignal ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: Display information about an application
cs: Zobrazuje informace o aplikaci

note: (itstool) path: page/p
en: An AboutDialog example using Gtk.ApplicationWindow and Menu
cs: Příklad s AboutDialog, který používá Gtk.ApplicationWindow a Menu

note: (itstool) path: note/p
en: <em style="bold">You need to be running Gtk3.4 or later for this to work</em>
cs: <em style="bold">Musíte používat Gtk 3.4 nebo novější, aby tento příklad fungoval.</em>

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    /* Callback function in which reacts to the "response" signal from the user in
     * the message dialog window.
     * This function is used to destroy the dialog window.
     */
    static void
    on_close (GtkDialog *dialog,
              gint       response_id,
              gpointer   user_data)
    {
      /* This will cause the dialog to be destroyed */
      gtk_widget_destroy (GTK_WIDGET (dialog));
    }
    
    /* Callback function for the response signal "activate" related to the SimpleAction
     * "about_action".
     * This function is used to cause the about dialog window to popup.
     */
    static void
    about_cb (GSimpleAction *simple,
              GVariant      *parameter,
              gpointer       user_data)
    {
      GtkWidget *about_dialog;
    
      about_dialog = gtk_about_dialog_new ();
    
      /* Lists of authors/ documenters to be used later, they must be initialized
       * in a null terminated array of strings.
       */
      const gchar *authors[] = {"GNOME Documentation Team", NULL};
      const gchar *documenters[] = {"GNOME Documentation Team", NULL};
    
      /* We fill in the information for the about dialog */
      gtk_about_dialog_set_program_name (GTK_ABOUT_DIALOG (about_dialog), "AboutDialog Example");
      gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG (about_dialog), "Copyright \xc2\xa9 2012 GNOME Documentation Team");
      gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG (about_dialog), authors);
      gtk_about_dialog_set_documenters (GTK_ABOUT_DIALOG (about_dialog), documenters);
      gtk_about_dialog_set_website_label (GTK_ABOUT_DIALOG (about_dialog), "GNOME Developer Website");
      gtk_about_dialog_set_website (GTK_ABOUT_DIALOG (about_dialog), "http://developer.gnome.org");
    
      /* We do not wish to show the title, which in this case would be
       * "AboutDialog Example". We have to reset the title of the messagedialog
       * window after setting the program name.
       */
      gtk_window_set_title (GTK_WINDOW (about_dialog), "");
    
      /* To close the aboutdialog when "close" is clicked we connect the response
       * signal to on_close
       */
      g_signal_connect (GTK_DIALOG (about_dialog), "response",
                        G_CALLBACK (on_close), NULL);
    
      /* Show the about dialog */
      gtk_widget_show (about_dialog);
    }
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
    
      GSimpleAction *about_action;
    
      /* Create a window with a title and a default size */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "AboutDialog Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
    
      /* Create a new simple action, giving it a NULL parameter type. It will
       * always be NULL for actions invoked from a menu. (e.g clicking on an "ok"
       * or "cancel" button)
       */
      about_action = g_simple_action_new ("about", NULL);
    
      /* Connect the "activate" signal to the appropriate callback function.
       * It will indicate that the action was just activated.
       */
      g_signal_connect (about_action, "activate", G_CALLBACK (about_cb),
                        GTK_WINDOW (window));
    
      /* Adds the about_action to the overall action map. An Action map is an
       * interface that contains a number of named GAction instances
       * (such as about_action)
       */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (about_action));
    
      gtk_widget_show_all (window);
    }
    
    /* Callback function for the response signal "activate" from the "quit" action
     * found in the function directly below.
     */
    static void
    quit_cb (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
      GApplication *application = user_data;
    
      g_application_quit (application);
    }
    
    /* Startup function for the menu we are creating in this sample */
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      GMenu *menu;
      GSimpleAction *quit_action;
    
      /* Initialize the GMenu, and add a menu item with label "About" and action
       * "win.about". Also add another menu item with label "Quit" and action
       * "app.quit"
       */
      menu = g_menu_new ();
      g_menu_append (menu, "About", "win.about");
      g_menu_append (menu, "Quit", "app.quit");
    
      /* Create a new simple action for the application. (In this case it is the
       * "quit" action.
       */
      quit_action = g_simple_action_new ("quit", NULL);
    
      /* Ensure that the menu we have just created is set for the overall application */
      gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (menu));
    
      g_signal_connect (quit_action,
                        "activate",
                        G_CALLBACK (quit_cb),
                        app);
    
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
    }
    
    /* Startup function for the application */
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    /* Funkce zpětného volání, ve které se reaguje na signál "response" od uživatele
     * v dialogovém okně se zprávou.
     * Tato funkce se používá ke zničení dialogového okna.
     */
    static void
    on_close (GtkDialog *dialog,
              gint       response_id,
              gpointer   user_data)
    {
      /* Toto způsobí, že dialogové okno bude zničeno */
      gtk_widget_destroy (GTK_WIDGET (dialog));
    }
    
    /* Callback function for the response signal "activate" related to the SimpleAction
     * "about_action".
     * This function is used to cause the about dialog window to popup.
     */
    /* Funkce zpětného volání, ve které se reaguje na signál "activate" vztahující se k
     * SimpleAction s názvem about_action.
     * Tato funkce se používá ke zobrazení dialogového okna O aplikaci.
     */
    static void
    about_cb (GSimpleAction *simple,
              GVariant      *parameter,
              gpointer       user_data)
    {
      GtkWidget *about_dialog;
    
       about_dialog = gtk_about_dialog_new ();
    
      /* Seznam autorů programu/dokumentace, který bude použit později, musí být inicializován
       * polem řetězců zakončených pomocí null.
       */
      const gchar *authors[] = {"GNOME Documentation Team", NULL};
      const gchar *documenters[] = {"GNOME Documentation Team", NULL};
    
      /* Vyplnění informací pro dialogové okno O aplikaci */
      gtk_about_dialog_set_program_name (GTK_ABOUT_DIALOG (about_dialog), "AboutDialog Example");
      gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG (about_dialog), "Copyright \xc2\xa9 2012 GNOME Documentation Team");
      gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG (about_dialog), authors);
      gtk_about_dialog_set_documenters (GTK_ABOUT_DIALOG (about_dialog), documenters);
      gtk_about_dialog_set_website_label (GTK_ABOUT_DIALOG (about_dialog), "GNOME Developer Website");
      gtk_about_dialog_set_website (GTK_ABOUT_DIALOG (about_dialog), "http://developer.gnome.org");
    
      /* Nepřejeme si zobrazení názvu okna, který by v tomto případě byl 
       * "AboutDialog Example". Musíme název dialogového okna se zprávou vymazat 
       * po nastavení názvu programu.
       */
      gtk_window_set_title (GTK_WINDOW (about_dialog), "");
    
      /* Pro zavření dialogového okna O aplikaci, kdyže je kliknuto na „Zavřít“ připojíme odpovídající 
       * signál k on_close
       */
      g_signal_connect (GTK_DIALOG (about_dialog), "response", 
                        G_CALLBACK (on_close), NULL);
    
      /* Zobrazení dialogového okna O aplikaci */
      gtk_widget_show (about_dialog); 
    }
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
    
      GSimpleAction *about_action;
    
      /* Vytvoření okna se záhlavím a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "AboutDialog Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
    
      /* Vytvoření nové jednoduché akce. Předává se jí parametr typu NULL. Bude 
       * vždy NULL pro akce vyvolané z nabídky. (například při kliknutí na tlačítko 
       * OK nebo Cancel)
       */
      about_action = g_simple_action_new ("about", NULL); 
    
      /* Připojení signálu "activate" k příslušné funkci zpětného volání. 
       * Bude indikovat, že akce již byla aktivována.
       */
      g_signal_connect (about_action, "activate", G_CALLBACK (about_cb), 
                        GTK_WINDOW (window));
    
      /* Přidání about_action do celkové mapy akcí. Mapa akcí je rozhraní, 
       * které obsahuje řadu pojmenovaných instancí GAction (jako je about_action) 
       */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (about_action));
    
      gtk_widget_show_all (window);
    }
    
    /* Funkce zpětného volání pro reakci na signál "activate" od akce „quit“ nacházející 
     * se hned v následující funkci níže.
     */ 
    static void
    quit_cb (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
      GApplication *application = user_data;
    
      g_application_quit (application);
    }
    
    /* Spouštěcí funkce pro nabídku vytvořenou v této ukázce */
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      GMenu *menu;
      GSimpleAction *quit_action;
    
      /* Inicializace GMenu a přidání položky nabídky s popiskem "About" a akcí 
       * "win.about". Dále se přidá položka s popiskem "Quit" a akcí "app.quit" 
       */
      menu = g_menu_new ();
      g_menu_append (menu, "About", "win.about");
      g_menu_append (menu, "Quit", "app.quit");
    
      /* Vytvoření nové jednoduché akce pro aplikaci. (V tomto případě se jedná o 
       * akci „quit“.
       */
      quit_action = g_simple_action_new ("quit", NULL);
    
      /* Ujištění, že již vytvořená nabídka je nastavená pro celou aplikaci  */
      gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (menu));
    
      g_signal_connect (quit_action, 
                        "activate", 
                        G_CALLBACK (quit_cb), 
                        app);
    
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
    
    }
    
    /* Spouštěcí funkce pro aplikaci */
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: page/p (itstool) path: section/p
en: In this sample we used the following:
cs: V této ukázce se používá následující:

note: (itstool) path: page/p
en: A modal dialog window which shows information about an application and its creators. This one is triggered by clicking "About" in the application's menu, which is normally a good place to put it.
cs: Modální dialogové okno, které zobrazuje informace o aplikaci a jejích autorech. Spouští se kliknutím na <gui>About</gui> v aplikační nabídce, což je pro ni normálně to správné místo.

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class AboutDialogExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsaboutdialog',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal creates the menu and builds the UI
        _onStartup() {
            this._initMenus();
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
            // Create the application window
            this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                       window_position: Gtk.WindowPosition.CENTER,
                                                       title: "AboutDialog Example",
                                                       default_height: 250,
                                                       default_width: 350 });
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        // Create the application menu
        _initMenus() {
            let menu = new Gio.Menu();
            menu.append("About", 'app.about');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            // Create the "About" menu option and have it call the _showAbout() function
            let aboutAction = new Gio.SimpleAction({ name: 'about' });
            aboutAction.connect('activate', () =&gt; { this._showAbout(); });
            this.application.add_action(aboutAction);
    
            // Create the "Quit" menu option and have it close the window
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
            this.application.add_action(quitAction);
        }
    
        _showAbout() {
    
            // String arrays of the names of the people involved in the project
            var authors = ["GNOME Documentation Team"];
            var documenters = ["GNOME Documentation Team"];
    
            // Create the About dialog
            let aboutDialog = new Gtk.AboutDialog({ title: "AboutDialog Example",
                                                    program_name: "GtkApplication Example",
                                                    copyright: "Copyright \xa9 2012 GNOME Documentation Team",
                                                    authors: authors,
                                                    documenters: documenters,
                                                    website: "http://developer.gnome.org",
                                                    website_label: "GNOME Developer Website" });
    
            // Attach the About dialog to the window
            aboutDialog.modal = true;
            aboutDialog.transient_for = this._window;
    
            // Show the About dialog
            aboutDialog.show();
    
            // Connect the Close button to the destroy signal for the dialog
            aboutDialog.connect('response', function() {
                aboutDialog.destroy();
            });
        }
    };
    
    // Run the application
    let app = new AboutDialogExample();
    app.application.run(ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class AboutDialogExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsaboutdialog',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._initMenus();
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                       window_position: Gtk.WindowPosition.CENTER,
                                                       title: "AboutDialog Example",
                                                       default_height: 250,
                                                       default_width: 350 });
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        // Vytvoří aplikační nabídku
        _initMenus() {
            let menu = new Gio.Menu();
            menu.append("About", 'app.about');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            // Vytvoří položku nabídky „About“ a dá ji za úkol volat funkci _showAbout()
            let aboutAction = new Gio.SimpleAction({ name: 'about' });
            aboutAction.connect('activate', () =&gt; { this._showAbout(); });
            this.application.add_action(aboutAction);
    
            // Vytvoří položku nabídky „Quit“ a dá ji za úkol zavřít okno
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
            this.application.add_action(quitAction);
        }
    
        _showAbout() {
    
            // Pole řetězců se jmény lidí, kteří se podílejí na projektu
            var authors = ["GNOME Documentation Team"];
            var documenters = ["GNOME Documentation Team"];
    
            // Vytvoří dialogové okno „O aplikaci“
            let aboutDialog = new Gtk.AboutDialog({ title: "AboutDialog Example",
                                                    program_name: "GtkApplication Example",
                                                    copyright: "Copyright \xa9 2012 GNOME Documentation Team",
                                                    authors: authors,
                                                    documenters: documenters,
                                                    website: "http://developer.gnome.org",
                                                    website_label: "GNOME Developer Website" });
    
            // Připojí dialogové okno „O aplikaci“ k oknu
            aboutDialog.modal = true;
            aboutDialog.transient_for = this._window;
    
            // Zobrazí dialogové okno „O aplikaci“
            aboutDialog.show();
    
            // Napojí tlačítko Close na signál "destroy" pro dialogové okno
            aboutDialog.connect('response', function() {
                aboutDialog.destroy();
            });
        }
    };
    
    // Spustí aplikaci
    let app = new AboutDialogExample();
    app.application.run(ARGV);

note: (itstool) path: info/desc
en: A window that displays information about an application
cs: Okno, které zobrazuje informace o aplikaci.

note: (itstool) path: page/p
en: An AboutDialog example using Gtk.ApplicationWindow and Menu (the "about" is displayed if "About" in the menu is selected).
cs: Příklad widgetu AboutDialog používající Gtk.ApplicationWindow a Menu (dialogové okno s informacemi o aplikaci se zobrazí, když je v nabídce vybráno „O aplikaci“).

note: (itstool) path: section/title
en: Code used to generate this example
cs: Kód použitý k vygenerování tohoto příkladu

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
         # constructor for a window (the parent window)
        def __init__(self, app):
            Gtk.Window.__init__(self, title="AboutDialog Example", application=app)
            self.set_default_size(200, 200)
    
            # create the about_action (a Gio.SimpleAction)
            about_action = Gio.SimpleAction.new("about", None)
            # connect the signal from the action to the function about_cb()
            about_action.connect("activate", self.about_cb)
            # add the action to the application
            app.add_action(about_action)
    
        # callback function for the about_action's "activate" signal
        def about_cb(self, action, parameter):
            # a  Gtk.AboutDialog
            aboutdialog = Gtk.AboutDialog()
    
            # lists of authors and documenters (will be used later)
            authors = ["GNOME Documentation Team"]
            documenters = ["GNOME Documentation Team"]
    
            # we fill in the aboutdialog
            aboutdialog.set_program_name("AboutDialog Example")
            aboutdialog.set_copyright(
                "Copyright \xc2\xa9 2012 GNOME Documentation Team")
            aboutdialog.set_authors(authors)
            aboutdialog.set_documenters(documenters)
            aboutdialog.set_website("http://developer.gnome.org")
            aboutdialog.set_website_label("GNOME Developer Website")
    
            # we do not want to show the title, which by default would be "About AboutDialog Example"
            # we have to reset the title of the messagedialog window after setting
            # the program name
            aboutdialog.set_title("")
    
            # to close the aboutdialog when "close" is clicked we connect the
            # "response" signal to on_close
            aboutdialog.connect("response", self.on_close)
            # show the aboutdialog
            aboutdialog.show()
    
        # destroy the aboutdialog
        def on_close(self, action, parameter):
            action.destroy()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def quit_cb(self, action, parameter):
            self.quit()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # create a menu (a Gio.Menu)
            menu = Gio.Menu()
            # append a menu item with label "About" and action "app.about"
            menu.append("About", "app.about")
            # append a menu item with label "Quit" and action "app.quit"
            menu.append("Quit", "app.quit")
            # set menu as the menu for the application
            self.set_app_menu(menu)
    
            # a new simpleaction - for the application
            quit_action = Gio.SimpleAction.new("quit", None)
            quit_action.connect("activate", self.quit_cb)
            self.add_action(quit_action)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
         # Konstruktor pro okno (rodičovské okno)
        def __init__(self, app):
            Gtk.Window.__init__(self, title="AboutDialog Example", application=app)
            self.set_default_size(200, 200)
    
            # Vytvoří about_action (Gio.SimpleAction)
            about_action = Gio.SimpleAction.new("about", None)
            # Napojí sognál od akce na funkci about_cb()
            about_action.connect("activate", self.about_cb)
            # Přidá akci do aplikace
            app.add_action(about_action)
    
        # Funkce zpětného volání pro signál "activate" od about_action
        def about_cb(self, action, parameter):
            # Gtk.AboutDialog
            aboutdialog = Gtk.AboutDialog()
    
            # Seznam autorů kódu a dokumentace (bude použit později)
            authors = ["GNOME Documentation Team"]
            documenters = ["GNOME Documentation Team"]
    
            # Vyplní údaje v aboutdialog
            aboutdialog.set_program_name("AboutDialog Example")
            aboutdialog.set_copyright(
                "Copyright \xc2\xa9 2012 GNOME Documentation Team")
            aboutdialog.set_authors(authors)
            aboutdialog.set_documenters(documenters)
            aboutdialog.set_website("http://developer.gnome.org")
            aboutdialog.set_website_label("GNOME Developer Website")
    
            # Nechceme zobrazit název v záhlaví, který je ve výchozím stavu "About 
            # AboutDialog Example", po nastavení názvu programu jej vymažeme
            aboutdialog.set_title("")
    
            # Pro zavření aboutdialog, když je kliknuto na tlačítko "Close",
            # napojíme signál "response" na on_close
            aboutdialog.connect("response", self.on_close)
            # Zobrazí aboutdialog
            aboutdialog.show()
    
        # Zlikviduje aboutdialog
        def on_close(self, action, parameter):
            action.destroy()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def quit_cb(self, action, parameter):
            self.quit()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # Vytvoří nabídku (Gio.Menu)
            menu = Gio.Menu()
            # Připojí do nabídky položku s popiskem „About“ a akcí „app.about“
            menu.append("About", "app.about")
            # Připojí do nabídky položku s popiskem „Quit“ a akcí „app.quit“
            menu.append("Quit", "app.quit")
            # Nastaví nabídku jako hlavní nabídku aplikace
            self.set_app_menu(menu)
    
            # Nová SimpleAction - pro aplikaci
            quit_action = Gio.SimpleAction.new("quit", None)
            quit_action.connect("activate", self.quit_cb)
            self.add_action(quit_action)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for an AboutDialog widget
cs: Užitečné metody pro widget AboutDialog

note: (itstool) path: section/p
en: In line 15 the signal <code>"activate"</code> is connected to the callback function <code>about_cb()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 15 je signál <code>"activate"</code> napojen na funkci zpětného volání <code>about_cb()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: section/title
en: API References
cs: Odkazy k API

note: (itstool) path: page/code
en: /* A window in the application */
    public class Window : Gtk.ApplicationWindow {
    
    	/* The constructor */
    	public Window (Application app) {
    		Object (application: app, title: "AboutDialog Example");
    
    		var about_action = new SimpleAction ("about", null);
    
    		about_action.activate.connect (this.about_cb);
    		this.add_action (about_action);
    		this.show_all ();
    	}
    
    	/* This is the callback function connected to the 'activate' signal
    	 * of the SimpleAction about_action.
    	 */
    	void about_cb (SimpleAction simple, Variant? parameter) {
    		string[] authors = { "GNOME Documentation Team", null };
    		string[] documenters = { "GNOME Documentation Team", null };
    
    		Gtk.show_about_dialog (this,
                                   "program-name", ("GtkApplication Example"),
                                   "copyright", ("Copyright \xc2\xa9 2012 GNOME Documentation Team"),
                                   "authors", authors,
                                   "documenters", documenters,
                                   "website", "http://developer.gnome.org",
                                   "website-label", ("GNOME Developer Website"),
                                   null);
    	}
    }
    
    /* This is the Application */
    public class Application : Gtk.Application {
    
    	/* Here we override the activate signal of GLib.Application */
    	protected override void activate () {
    		new Window (this);
    	}
    
    	/* Here we override the startup signal of GLib.Application */
    	protected override void startup () {
    
    		base.startup ();
    
    		var menu = new Menu ();
    		menu.append ("About", "win.about");
    		menu.append ("Quit", "app.quit");
    		this.app_menu = menu;
    
    		var quit_action = new SimpleAction ("quit", null);
    		//quit_action.activate.connect (this.quit);
    		this.add_action (quit_action);
    	}
    
    	/* The constructor */
    	public Application () {
    		Object (application_id: "org.example.application");
    	}
    }
    
    /* main function creates Application and runs it */
    int main (string[] args) {
    	return new Application ().run (args);
    }
cs: /* Okno v aplikaci */
    public class Window : Gtk.ApplicationWindow {
    
    	/* Konstruktor */
    	public Window (Application app) {
    		Object (application: app, title: "AboutDialog Example");
    
    		var about_action = new SimpleAction ("about", null);
    
    		about_action.activate.connect (this.about_cb);
    		this.add_action (about_action);
    		this.show_all ();
    	}
    
    	/* Toto je funkce zpětného volání napojená na signál "activate"
    	 * od SimpleAction about_action.
    	 */
    	void about_cb (SimpleAction simple, Variant? parameter) {
    		string[] authors = { "GNOME Documentation Team", null };
    		string[] documenters = { "GNOME Documentation Team", null };
    
    		Gtk.show_about_dialog (this,
                                   "program-name", ("GtkApplication Example"),
                                   "copyright", ("Copyright \xc2\xa9 2012 GNOME Documentation Team"),
                                   "authors", authors,
                                   "documenters", documenters,
                                   "website", "http://developer.gnome.org",
                                   "website-label", ("GNOME Developer Website"),
                                   null);
    	}
    }
    
    /* Toto je aplikace */
    public class Application : Gtk.Application {
    
    	/* Zde se přepíše signál "activate" z GLib.Application */
    	protected override void activate () {
    		new Window (this);
    	}
    
    	/* Zde se přepíše signál "startup" z GLib.Application */
    	protected override void startup () {
    
    		base.startup ();
    
    		var menu = new Menu ();
    		menu.append ("About", "win.about");
    		menu.append ("Quit", "app.quit");
    		this.app_menu = menu;
    
    		var quit_action = new SimpleAction ("quit", null);
    		//quit_action.activate.connect (this.quit);
    		this.add_action (quit_action);
    	}
    
    	/* Konstruktor */
    	public Application () {
    		Object (application_id: "org.example.application");
    	}
    }
    
    /* Funkce main vytvoří aplikaci a spustí ji */
    int main (string[] args) {
    	return new Application ().run (args);
    }

note: (itstool) path: info/desc
en: Coming soon...
cs: Připravuje se…

note: (itstool) path: credit/name
en: GNOME Documentation Project
cs: Dokumentační projekt GNOME

note: (itstool) path: page/title
en: Audio player
cs: Hudební přehrávač

note: (itstool) path: info/desc
en: A beginner's guide to writing GNOME applications in JavaScript, including code samples and practice exercises.
cs: Příručka pro začátečníky o psaní aplikací GNOME v jazyce JavaScript, včetně ukázek kódu a praktických cvičení.

note: (itstool) path: page/title
en: Tutorial for beginners and code samples
cs: Výuka pro začátečníky a ukázkový kód

note: (itstool) path: synopsis/p
en: JavaScript is one of the most popular programming languages on the web. It's not just for the web, though. If you have even a basic understanding of JavaScript, you can write full-fledged applications for GNOME. <link href="https://wiki.gnome.org/Apps/Documents">GNOME Documents</link> is written in JavaScript, and so is <link href="https://live.gnome.org/GnomeShell/Tour">GNOME Shell</link>, the most basic part of GNOME.
cs: JavaScript je jeden z nejpopulárnějších programovacích jazyků na webu. Ale není jen pro web. Pokud máte i jen základní znalosti jazyka JavaScript, můžete psát plnohodnotné aplikace pro GNOME. Aplikace <link href="https://wiki.gnome.org/Apps/Documents">Dokumenty GNOME</link> je napsaná v jazyce JavaScript a také některé základní části <link href="https://live.gnome.org/GnomeShell/Tour">GNOME Shell</link>.

note: (itstool) path: note/p
en: GNOME Shell is what you see when you click on "Activities" in the top-left corner of your screen. It also controls the clock and the rest of the top panel. Besides showing how you to write GNOME applications, these tutorials will also show you how to use JavaScript to write GNOME Shell extensions, which give it new features or change the way it does things.
cs: GNOME Shell je to, co uvidíte, když kliknete na „Činnosti“ v levém horním rohu obrazovky. Rovněž se stará o hodiny a zbytek věcí na horní liště. Kromě názorného předvedení, jak psát aplikace GNOME, v těchto lekcích uvidíte i jak použít JavaScript k psaní rozšíření pro GNOME Shell, kterými mu můžete dát novou funkčnost nebo změnit tu stávající.

note: (itstool) path: section/title
en: Getting Started
cs: Začínáme

note: (itstool) path: section/p
en: These tutorials are designed for people who already know how to write in JavaScript, and who have GNOME installed on their computers already, but who are new to developing GNOME applications. If you don't already know JavaScript, or if you need help getting GNOME set up, take a look at these resources first:
cs: Tato výuka je napsána pro lidi, kteří již mají znalosti programování v jazyce JavaScript a mají nainstalováno prostředí GNOME ve svém počítači, ale jsou nováčky ve vývoji aplikací pro GNOME. V případě, že JavaScript zatím neznáte nebo potřebujete pomoc s pořízením GNOME, podívejte se nejprve do těchto zdrojů:

note: (itstool) path: item/p
en: <link href="http://eloquentjavascript.net/contents.html">Eloquent JavaScript</link> is a free, Creative Commons-licensed book, which explains the basics of JavaScript programming. Since you won't be writing JavaScript for the web, you only need to read up to chapter 10 or so.
cs: <link href="http://eloquentjavascript.net/contents.html">Výmluvný JavaScript</link> je svobodná kniha pod licencí Creative Commons, která vysvětluje základy programování v jazyce JavaScript. Protože nechcete psát JavaScript pro web, stačí vám začít číst od kapitoly 10 dále.

note: (itstool) path: item/p
en: <link href="http://www.gnome.org/getting-gnome/">Download GNOME</link> as part of a distribution, like Fedora, openSUSE, or Ubuntu. Each distribution has its own instructions for how to get GNOME.
cs: <link href="http://www.gnome.org/getting-gnome/">Stažení GNOME</link> jako součásti distribuce, jako je Fedora, openSUSE nebo Ubuntu. Každá distribuce má svůj vlastní postup, jak získat GNOME.

note: (itstool) path: item/p
en: <link xref="set-up-gedit.js">Set up gedit</link> for writing applications. GNOME's text editor, gedit, is sometimes just called "text editor".
cs: <link xref="set-up-gedit.js">Nastavte si editor gedit</link> pro psaní aplikací. Někdy bývá gedit v GNOME nazýván jen „textový editor“.

note: (itstool) path: section/title
en: Tutorials
cs: Výuka

note: (itstool) path: section/title
en: Code samples
cs: Ukázky kódu

note: (itstool) path: section/p
en: These samples show how to use widgets in your GNOME applications. Each one demonstrates a complete application which showcases the featured widget. At the end of each sample, you will find links to more detailed reference material.
cs: Tyto ukázky předvádí, jak používat widgety ve svých aplikacích pro GNOME. Každá z nich předvádí ucelenou aplikaci, na které je ukázán rozebíraný widget. Na konci každé ukázky můžete najít odkazy na podrobnější studijní materiály.

note: (itstool) path: section/p
en: To run the code samples:
cs: Když chcete spustit ukázkový kód:

note: (itstool) path: item/p
en: Copy and paste the code into <var>filename</var>.js
cs: Zkopírujte a vložte kód do <var>název_souboru</var>.js

note: (itstool) path: item/p
en: In the terminal, type:
cs: V terminálu napište:

note: (itstool) path: item/screen
en: gjs <var>filename</var>.js
cs: gjs <var>název_souboru</var>.js

note: (itstool) path: section/title
en: Windows
cs: Okna

note: (itstool) path: section/title
en: Display widgets
cs: Zobrazovací widgety

note: (itstool) path: section/title
en: Buttons and toggles
cs: Tlačítka a přepínače

note: (itstool) path: section/title
en: Numeric and text data entry
cs: Vstupní pole pro čísla a text

note: (itstool) path: section/title
en: Multiline text editor
cs: Víceřádkové editory textu

note: (itstool) path: section/title
en: Menu, combo box and toolbar widgets
cs: Nabídky, rozbalovací seznamy a nástrojové lišty

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

note: (itstool) path: section/title (itstool) path: steps/title
en: Selectors
cs: Widgety pro výběr

note: (itstool) path: section/title
en: File selectors
cs: Výběr souborů

note: (itstool) path: section/title
en: Font selectors
cs: Výběr písma

note: (itstool) path: section/title
en: Color Selectors
cs: Výběr barev

note: (itstool) path: section/title
en: Layout containers
cs: Kontejnery vytvářející rozvržení

note: (itstool) path: section/title
en: Ornaments
cs: Zdobení

note: (itstool) path: section/title
en: Scrolling
cs: Posouvání

note: (itstool) path: section/title
en: Miscellaneous
cs: Různé

note: (itstool) path: section/title
en: Exercises
cs: Cvičení

[ctx: text]
note: (itstool) path: info/title
en: GTK+ widgets sample code (Python)
cs: Ukázkový kód s widgety GTK+ (Python)

note: (itstool) path: info/desc
en: A guide to GUI programming using GTK+, including code samples and practice exercises.
cs: Příručka k programování GUI pomocí GTK+, včetně ukázek kódu a praktických cvičení.

note: (itstool) path: page/title
en: GTK+ widgets sample code
cs: Ukázkový kód s widgety GTK+

note: (itstool) path: synopsis/p
en: If you are a beginner and you would like a tutorial to guide you step by step in an exploration of what you can do with GTK+ 3, you should go to the <link xref="tutorial.py"/> page. If you are looking for a specific widget, you can find it in the sections below.
cs: Pokud jste začátečník a rádi byste průvodce, který by vám krok za krokem vysvětlil, co můžete dělat s GTK 3+, měli byste se podívat na stránku <link xref="tutorial.py"/>. Jestli hledáte konkrétní widget, hledejte jej ve spodní části stránky.

note: (itstool) path: section/title
en: Theory pages
cs: Stránky s teorií

[ctx: text]
note: (itstool) path: info/title
en: Tutorial for beginners (Vala)
cs: Výuka pro začátečníky (Vala)

note: (itstool) path: info/desc
en: A beginner's guide to GUI programming using GTK+, including code samples and practice exercises.
cs: Začátečnická příručka k programování GUI pomocí GTK+, včetně ukázek kódu a praktických cvičení.

note: (itstool) path: synopsis/p
en: Although these tutorials are designed for beginners, we can't cover all the basics. Before attempting to follow these tutorials, you are expected to be familiar with the following concepts:
cs: Ačkoliv je tato výuka navržena pro začátečníky, nemůže pokrýt úplně všechny základy. Než se pustíte do této výuky, očekává se od vás znalost následujících konceptů:

note: (itstool) path: item/p
en: Object oriented programming
cs: Objektově orientované programování

note: (itstool) path: item/p
en: The Vala programming language:
cs: Programovací jazyk Vala:

note: (itstool) path: item/p
en: <link href="https://live.gnome.org/Vala/Tutorial">The Vala Tutorial</link>
cs: <link href="https://live.gnome.org/Vala/Tutorial">Výuka jazyka Vala</link>

note: (itstool) path: item/p
en: <link href="https://live.gnome.org/Vala/Documentation#Sample_Code">Sample Vala code</link>
cs: <link href="https://live.gnome.org/Vala/Documentation#Sample_Code">Ukázkový kód v jazyce Vala</link>

note: (itstool) path: synopsis/p
en: By following these tutorials you will learn the basics of GUI programming using GTK+.
cs: V této lekci se naučíte základy programování GUI pomocí GTK+.

note: (itstool) path: item/p
en: Copy and paste the code into <var>filename</var>.vala
cs: Zkopírujte a vložte kód do <var>název_souboru</var>.vala

note: (itstool) path: item/p
en: In the terminal type:
cs: V terminálu napište:

note: (itstool) path: item/screen
en: valac --pkg gtk+-3.0 <var>filename</var>.vala
cs: valac --pkg gtk+-3.0 <var>název_souboru</var>.vala

note: (itstool) path: item/screen
en: ./<var>filename</var>
cs: ./<var>název_souboru</var>

note: (itstool) path: info/desc
en: A button widget which emits a signal when clicked
cs: Widget tlačítka, který vyšle signál při kliknutí

note: (itstool) path: page/p
en: A button widget connected to a callback function that reverses its label when clicked.
cs: Widget tlačítka napojený na funkci zpětného volání, která při kliknutí otočí pořadí jeho popisku.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /*This is the callback function. It is a handler function which 
    reacts to the signal. In this case, it will cause the button label's 
    string to reverse.*/
    static void
    button_clicked (GtkButton *button,
                    gpointer   user_data)
    {
      const char *old_label;
      char *new_label;
    
      old_label = gtk_button_get_label (button);
      new_label = g_utf8_strreverse (old_label, -1);
    
      gtk_button_set_label (button, new_label);
      g_free (new_label);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *button;
    
      /*Create a window with a title and a default size*/
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "GNOME Button");
      gtk_window_set_default_size (GTK_WINDOW (window), 250, 50);
    
      /*Create a button with a label, and add it to the window*/
      button = gtk_button_new_with_label ("Click Me");
      gtk_container_add (GTK_CONTAINER (window), button);
    
      /*Connecting the clicked signal to the callback function*/
      g_signal_connect (GTK_BUTTON (button),
                        "clicked", 
                        G_CALLBACK (button_clicked), 
                        G_OBJECT (window));
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Toto je funkce zpětného volání. Jedná se o zpracující funkci, která 
    raguje na signál. V tomto případě způsobí otočení text na popisku tlačítka 
    do opačného pořadí. */
    static void
    button_clicked (GtkButton *button,
                    gpointer   user_data)
    {
      const char *old_label;
      char *new_label;
    
      old_label = gtk_button_get_label (button);
      new_label = g_utf8_strreverse (old_label, -1);
    
      gtk_button_set_label (button, new_label);
      g_free (new_label);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *button;
    
      /* Vytvoření okna s názvem a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "GNOME Button");
      gtk_window_set_default_size (GTK_WINDOW (window), 250, 50);
    
      /* Vytvoření tlačítka s popiskem a jeho přidání do okna */
      button = gtk_button_new_with_label ("Click Me");
      gtk_container_add (GTK_CONTAINER (window), button);
    
      /* Připojení signálu kliknutí na funkci zpětného volání */
      g_signal_connect (GTK_BUTTON (button),
                        "clicked", 
                        G_CALLBACK (button_clicked), 
                        G_OBJECT (window));
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/glib/stable/glib-Unicode-Manipulation.html#g-utf8-strreverse">Unicode Manipulation</link>
cs: <link href="http://developer.gnome.org/glib/stable/glib-Unicode-Manipulation.html#g-utf8-strreverse">Práce s Unikódem</link>

note: (itstool) path: info/desc
en: A button which can be connected to other widgets
cs: Tlačítko, které může být napojené na další widgety

note: (itstool) path: page/p
en: A button widget that changes its label when you click it.
cs: Widget tlačítko, který po kliknutí změní svůj popisek.

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class ButtonExample {
    
        /* Create the application itself
           This boilerplate code is needed to build any GTK+ application. */
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jsbutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present ();
        }
    
        // Callback function for 'startup' signal initializes menus and builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
                this._window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                                  window_position: Gtk.WindowPosition.CENTER,
                                                                  title: "GNOME Button",
                                                                  default_height: 50,
                                                                  default_width: 250 });
    
            // Create the button
            this.Button = new Gtk.Button ({label: "Click Me"});
            this._window.add (this.Button);
    
            // Bind it to a function that says what to do when the button is clicked
            this.Button.connect ("clicked", this._clickHandler.bind(this));
    
                    // Show the window and all child widgets
                    this._window.show_all();
        }
    
        // Here's the function that says what happens when the button is clicked
        _clickHandler() {
            this.Button.set_label ("Clicked!");
        }
    };
    
    // Run the application
    let app = new ButtonExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class ButtonExample {
    
        /* Vytvoří vlastní aplikaci
           Tento základní kód je zapotřebí k sestavení kterékoliv aplikace GTK+. */
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jsbutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present ();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
                this._window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                                  window_position: Gtk.WindowPosition.CENTER,
                                                                  title: "GNOME Button",
                                                                  default_height: 50,
                                                                  default_width: 250 });
    
            // Vytvoří tlačítko
            this.Button = new Gtk.Button ({label: "Click Me"});
            this._window.add (this.Button);
    
            // Napojí jej na funkci, která říká, co udělat, když je na tlačítko kliknuto
            this.Button.connect ("clicked", this._clickHandler.bind(this));
    
                    // Zobrazí okno a všechny jeho synovské widgety
                    this._window.show_all();
        }
    
        // Zde je funkce, která říká, co se stalo, když bylo na tlačítko kliknuto
        _clickHandler() {
            this.Button.set_label ("Clicked!");
        }
    };
    
    // Spustí aplikaci
    let app = new ButtonExample ();
    app.application.run (ARGV);

note: (itstool) path: page/p
en: A button widget connected to a simple callback function.
cs: Widget tlačítka napojený na jednoduchou funkci zpětného volání.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # a window
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="GNOME Button", application=app)
            self.set_default_size(250, 50)
    
            # a button
            button = Gtk.Button()
            # with a label
            button.set_label("Click me")
            # connect the signal "clicked" emitted by the button
            # to the callback function do_clicked
            button.connect("clicked", self.do_clicked)
            # add the button to the window
            self.add(button)
    
        # callback function connected to the signal "clicked" of the button
        def do_clicked(self, button):
            print("You clicked me!")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # Okno
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="GNOME Button", application=app)
            self.set_default_size(250, 50)
    
            # Tlačítko
            button = Gtk.Button()
            # s popiskem
            button.set_label("Click me")
            # Napojí signál "clicked" vyslaný tlačítkem
            # na funkci zpětného volání do_clicked
            button.connect("clicked", self.do_clicked)
            # Přidá tlačítko do okna
            self.add(button)
    
        # Funkce zpětného volání napojená na signál "clicked" od tlačítka
        def do_clicked(self, button):
            print("You clicked me!")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Button widget
cs: Užitečné metody pro widget Button

note: (itstool) path: section/p
en: In line 16 the <code>"clicked"</code> signal from the button is connected to the callback function <code>do_clicked()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 16 je signál <code>"clicked"</code> od tlačítka napojen na funkci zpětného volání <code>do_clicked()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: <code>set_relief(Gtk.ReliefStyle.NONE)</code> sets to none the relief style of the edges of the Gtk.Button - as opposed to <code>Gtk.ReliefStyle.NORMAL</code>.
cs: <code>set_relief(Gtk.ReliefStyle.NONE)</code> nastaví styl reliéfu hran u Gtk.Button na žádný – oproti <code>Gtk.ReliefStyle.NORMAL</code>.

note: (itstool) path: item/p
en: If the label of the button is a <link href="http://developer.gnome.org/gtk3/unstable/gtk3-Stock-Items.html">stock icon</link>, <code>set_use_stock(True)</code> sets the label as the name of the corresponding stock icon.
cs: V případě, že je popiskem tlačítka <link href="http://developer.gnome.org/gtk3/unstable/gtk3-Stock-Items.html">standardní ikona</link>, <code>set_use_stock(True)</code> nastaví <code>label</code> jako odpovídající název standardní ikony.

note: (itstool) path: item/p
en: To set an image (e.g. a stock image) for the button <code>button</code>:
cs: Pro nastavení obrázku (např. standardního obrázku) u tlačítka <code>button</code>:

note: (itstool) path: item/p
en: You should not set a label for the button after this, otherwise it will show the label and not the image.
cs: Po provedení této části kódu už byste neměli nastavovat popisek pro tlačítko, jinak bude zobrazovat popisek a ne obrázek.

note: (itstool) path: item/p
en: If we use <code>set_focus_on_click(False)</code> the button will not grab focus when it is clicked by the mouse. This could be useful in places like toolbars, so that the keyboard focus is not removed from the main area of the application.
cs: Když použijeme <code>set_focus_on_click(False)</code>, nebude tlačítko přebírat zaměření při kliknutí myší. To se může hodit na místech, jako je nástrojová lišta, aby nebylo přebráno zaměření klávesnice do hlavní části aplikace.

note: (itstool) path: page/title
en: Button widget
cs: Widget Button

note: (itstool) path: page/code
en: 
    /* A window in the application */
    public class MyWindow : Gtk.ApplicationWindow {
    
    	/* The constructor of the window */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "GNOME Button");
    
    		var button = new Gtk.Button.with_label ("Click Me");
    		button.clicked.connect (this.reverse_label);
    		button.show ();
    
    		this.window_position = Gtk.WindowPosition.CENTER;
    		this.set_default_size (250,50);
    		this.add (button);
    	}
    
    	/* The callback function connected to the
    	 * 'clicked' signal of the button.
    	 */
    	void reverse_label (Gtk.Button button) {
    		button.label = button.label.reverse ();
    	}
    }
    
    /* This is the application. */
    public class MyApplication : Gtk.Application {
    
    	/* This is the constructor */
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    
    	/* Override the activate signal of GLib.Application */
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    }
    
    /* main creates and runs the application */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: 
    /* Okno v aplikaci */
    public class MyWindow : Gtk.ApplicationWindow {
    
    	/* Konstruktor okna */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "GNOME Button");
    
    		var button = new Gtk.Button.with_label ("Click Me");
    		button.clicked.connect (this.reverse_label);
    		button.show ();
    
    		this.window_position = Gtk.WindowPosition.CENTER;
    		this.set_default_size (250,50);
    		this.add (button);
    	}
    
    	/* Funkce zpětného volání napojen na
    	 * signál "clicked" tlačítka
    	 */
    	void reverse_label (Gtk.Button button) {
    		button.label = button.label.reverse ();
    	}
    }
    
    /* Toto je aplikace */
    public class MyApplication : Gtk.Application {
    
    	/* Toto je konstruktor */
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    
    	/* Přepíše signál "activate" z GLib.Application */
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    }
    
    /* main vytvoří a spustí aplikaci */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: page/p
en: In this sample we used the following: <link href="http://www.valadoc.org/gtk+-3.0/Gtk.Button.html">Gtk.Button</link>
cs: V této ukázce se používá následující: <link href="http://www.valadoc.org/gtk+-3.0/Gtk.Button.html">Gtk.Button</link>

note: (itstool) path: info/desc
en: A container for arranging buttons
cs: Kontejner pro uspořádání tlačítek

note: (itstool) path: page/p
en: A calculator - the buttons are enclosed in horizontal ButtonBoxes.
cs: Kalkulačka – tlačítka jsou umístěna do vodorovných widgetů ButtonBox.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const GObject = imports.gi.GObject;
    const Gtk = imports.gi.Gtk;
    
    class ButtonBoxExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsbuttonbox'
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this.window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
            // Create the application window
            this.window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                        window_position: Gtk.WindowPosition.CENTER,
                                                        title: "Calculator",
                                                        default_width: 350,
                                                        default_height: 200,
                                                        border_width: 10 });
            this.entry = new Gtk.Entry();
            this.entry.set_text('0');
            // text aligned on the right
            this.entry.set_alignment(1);
            // the text in the entry cannot be modified by writing in it
            this.entry.set_can_focus(false);
    
            // a grid
            this.grid = new Gtk.Grid();
            this.grid.set_row_spacing(5);
            
            // to attach the entry
            this.grid.attach(this.entry, 0, 0, 1, 1);
            
            // the labels for the buttons
            this.buttons = [ 7, 8, 9, '/', 4, 5, 6, '*', 1, 2, 3, '-', 'C', 0, '=', '+' ];
            
            // each row is a ButtonBox, attached to the grid            
            for (let i = 0; i &lt; 4; i++) {
                this.hbox = Gtk.ButtonBox.new(Gtk.Orientation.HORIZONTAL);
                this.hbox.set_spacing(5);
                this.grid.attach(this.hbox, 0, i + 1, 1, 1);
                // each ButtonBox has 4 buttons, connected to the callback function
                for (let j= 0; j &lt; 4; j++) {
                    this.button = new Gtk.Button();
                    this.buttonLabel = (this.buttons[i * 4 + j].toString());
                    this.button.set_label(this.buttonLabel);
                    this.button.set_can_focus(false);
                    this.button.connect("clicked", this._buttonClicked.bind(this));
                    this.hbox.add(this.button);
                }
            }
                
            // some variables for the calculations
            this.firstNumber = 0;
            this.secondNumber = 0;
            this.counter = 0;
            this.operation = "";
    
            // add the grid to the window
            this.window.add(this.grid);
            this.window.show_all();
        }
    
        // callback function for all the buttons
        _buttonClicked(button) {
            this.button = button;
            // for the operations
            if (this.button.get_label() == '+') {
                this.counter += 1 
                if (this.counter &gt; 1)
                    this._doOperation();
                this.entry.set_text('0');
                this.operation = "plus";
            }
    
            else if (this.button.get_label() == '-') {
                this.counter += 1;
                if (this.counter &gt; 1)
                    this._doOperation();
                this.entry.set_text('0');
                this.operation = "minus";
            }
    
            else if (this.button.get_label() == '*') {
                this.counter += 1; 
                if (this.counter &gt; 1)
                    this._doOperation();
                this.entry.set_text('0');
                this.operation = "multiplication";
            }
    
            else if (this.button.get_label() == '/') {
                this.counter += 1 
                if (this.counter &gt; 1)
                    this._doOperation();
                this.entry.set_text('0');
                this.operation = "division";
            }
    
            // for =
            else if (this.button.get_label() == '=') {
                this._doOperation();
                this.entry.set_text(this.firstNumber.toString());
                this.counter = 1;
            }
    
            // for Cancel
            else if (this.button.get_label() == 'C') {
                this.firstNumber = 0;
                this.secondNumber = 0;
                this.counter = 0;
                this.entry.set_text('0');
                this.operation = "";
            }
    
            // for a digit button
            else {
                this.newDigit = parseInt(this.button.get_label());
                if (this.entry.get_text() == "error")
                    this.number = 0;
                else
                    this.number = parseInt(this.entry.get_text());
                this.number = this.number * 10 + this.newDigit;            
                if (this.counter == 0)
                    this.firstNumber = this.number;
                else
                    this.secondNumber = this.number;
                this.entry.set_text(this.number.toString());
            }
         }
    
         _doOperation() {
            if (this.operation == "plus") {
               this.firstNumber += this.secondNumber;
            } else if (this.operation == "minus") {
                this.firstNumber -= this.secondNumber;
            } else if (this.operation == "multiplication") {
                this.firstNumber *= this.secondNumber;
            } else if (this.operation == "division") {
                if (this.secondNumber != 0) {
                    this.firstNumber /= this.secondNumber;
                } else {
                    this.firstNumber = 0; 
                    this.secondNumber = 0;
                    this.counter = 0; 
                    this.entry.set_text("error");
                    this.operation = "";
    
                    return
                }
            } else {
                this.firstNumber = 0;
                this.secondNumber = 0;
                this.counter = 0;
                this.entry.set_text("error");
            }
        }
    };
    
    // Run the application
    let app = new ButtonBoxExample();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const GObject = imports.gi.GObject;
    const Gtk = imports.gi.Gtk;
    
    class ButtonBoxExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsbuttonbox'
            });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this.window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
            // Vytvoří okno aplikace
            this.window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                        window_position: Gtk.WindowPosition.CENTER,
                                                        title: "Calculator",
                                                        default_width: 350,
                                                        default_height: 200,
                                                        border_width: 10 });
            this.entry = new Gtk.Entry();
            this.entry.set_text('0');
            // Text zarovnaný doprava
            this.entry.set_alignment(1);
            // Text ve vstupním poli nelze měnit psaním
            this.entry.set_can_focus(false);
    
            // Mřížka
            this.grid = new Gtk.Grid();
            this.grid.set_row_spacing(5);
            
            // Připojí vstupní pole
            this.grid.attach(this.entry, 0, 0, 1, 1);
            
            // Popisky pro tlačítka
            this.buttons = [ 7, 8, 9, '/', 4, 5, 6, '*', 1, 2, 3, '-', 'C', 0, '=', '+' ];
            
            // Každý řádek je ButtonBox připojený do mřížky
            for (let i = 0; i &lt; 4; i++) {
                this.hbox = Gtk.ButtonBox.new(Gtk.Orientation.HORIZONTAL);
                this.hbox.set_spacing(5);
                this.grid.attach(this.hbox, 0, i + 1, 1, 1);
                // Každý ButtonBox má 4 tlačítka napojená na funkci zpětného volání
                for (let j= 0; j &lt; 4; j++) {
                    this.button = new Gtk.Button();
                    this.buttonLabel = (this.buttons[i * 4 + j].toString());
                    this.button.set_label(this.buttonLabel);
                    this.button.set_can_focus(false);
                    this.button.connect("clicked", this._buttonClicked.bind(this));
                    this.hbox.add(this.button);
                }
            }
                
            // Pár proměnných pro výpočty
            this.firstNumber = 0;
            this.secondNumber = 0;
            this.counter = 0;
            this.operation = "";
    
            // Přídá mřížku do okna
            this.window.add(this.grid);
            this.window.show_all();
        }
    
        // Funkce zpětného volání pro všechna tlačítka
        _buttonClicked(button) {
            this.button = button;
            // Pro početní operace
            if (this.button.get_label() == '+') {
                this.counter += 1 
                if (this.counter &gt; 1)
                    this._doOperation();
                this.entry.set_text('0');
                this.operation = "plus";
            }
    
            else if (this.button.get_label() == '-') {
                this.counter += 1;
                if (this.counter &gt; 1)
                    this._doOperation();
                this.entry.set_text('0');
                this.operation = "minus";
            }
    
            else if (this.button.get_label() == '*') {
                this.counter += 1; 
                if (this.counter &gt; 1)
                    this._doOperation();
                this.entry.set_text('0');
                this.operation = "multiplication";
            }
    
            else if (this.button.get_label() == '/') {
                this.counter += 1 
                if (this.counter &gt; 1)
                    this._doOperation();
                this.entry.set_text('0');
                this.operation = "division";
            }
    
            // Pro =
            else if (this.button.get_label() == '=') {
                this._doOperation();
                this.entry.set_text(this.firstNumber.toString());
                this.counter = 1;
            }
    
            // Pro mazání
            else if (this.button.get_label() == 'C') {
                this.firstNumber = 0;
                this.secondNumber = 0;
                this.counter = 0;
                this.entry.set_text('0');
                this.operation = "";
            }
    
            // Pro číslice
            else {
                this.newDigit = parseInt(this.button.get_label());
                if (this.entry.get_text() == "error")
                    this.number = 0;
                else
                    this.number = parseInt(this.entry.get_text());
                this.number = this.number * 10 + this.newDigit;            
                if (this.counter == 0)
                    this.firstNumber = this.number;
                else
                    this.secondNumber = this.number;
                this.entry.set_text(this.number.toString());
            }
         }
    
         _doOperation() {
            if (this.operation == "plus") {
               this.firstNumber += this.secondNumber;
            } else if (this.operation == "minus") {
                this.firstNumber -= this.secondNumber;
            } else if (this.operation == "multiplication") {
                this.firstNumber *= this.secondNumber;
            } else if (this.operation == "division") {
                if (this.secondNumber != 0) {
                    this.firstNumber /= this.secondNumber;
                } else {
                    this.firstNumber = 0; 
                    this.secondNumber = 0;
                    this.counter = 0; 
                    this.entry.set_text("error");
                    this.operation = "";
    
                    return
                }
            } else {
                this.firstNumber = 0;
                this.secondNumber = 0;
                this.counter = 0;
                this.entry.set_text("error");
            }
        }
    };
    
    // Spustí aplikaci
    let app = new ButtonBoxExample();
    app.application.run (ARGV);

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Calculator", application=app)
            self.set_default_size(350, 200)
            self.set_border_width(10)
    
            # an entry
            self.entry = Gtk.Entry()
            # with an initial text
            self.entry.set_text('0')
            # text aligned on the right
            self.entry.set_alignment(1)
            # the text in the entry cannot be modified writing in it
            self.entry.set_can_focus(False)
    
            # a grid
            grid = Gtk.Grid()
            grid.set_row_spacing(5)
    
            # to attach the entry
            grid.attach(self.entry, 0, 0, 1, 1)
    
            # the labels for the buttons
            buttons = [7, 8, 9, '/',
                       4, 5, 6, '*',
                       1, 2, 3, '-',
                       'C', 0, '=', '+']
    
            # each row is a ButtonBox, attached to the grid
            for i in range(4):
                hbox = Gtk.ButtonBox.new(Gtk.Orientation.HORIZONTAL)
                hbox.set_spacing(5)
                grid.attach(hbox, 0, i + 1, 1, 1)
                # each ButtonBox has 4 buttons, connected to the callback function
                for j in range(4):
                    button = Gtk.Button(label=buttons[i * 4 + j])
                    button.set_can_focus(False)
                    button.connect("clicked", self.button_clicked)
                    hbox.add(button)
    
            # some variables for the calculations
            self.first_number = 0
            self.second_number = 0
            self.counter = 0
            self.operation = ""
    
            # add the grid to the window
            self.add(grid)
    
        # callback function for all the buttons
        def button_clicked(self, button):
            # for the operations
            if button.get_label() == '+':
                self.counter += 1
                if self.counter &gt; 1:
                    self.do_operation()
                self.entry.set_text('0')
                self.operation = "plus"
            elif button.get_label() == '-':
                self.counter += 1
                if self.counter &gt; 1:
                    self.do_operation()
                self.entry.set_text('0')
                self.operation = "minus"
            elif button.get_label() == '*':
                self.counter += 1
                if self.counter &gt; 1:
                    self.do_operation()
                self.entry.set_text('0')
                self.operation = "multiplication"
            elif button.get_label() == '/':
                self.counter += 1
                if self.counter &gt; 1:
                    self.do_operation()
                self.entry.set_text('0')
                self.operation = "division"
            # for =
            elif button.get_label() == '=':
                self.do_operation()
                self.entry.set_text(str(self.first_number))
                self.counter = 1
            # for Cancel
            elif button.get_label() == 'C':
                self.first_number = 0
                self.second_number = 0
                self.counter = 0
                self.entry.set_text('')
                self.operation = ""
            # for a digit button
            else:
                new_digit = int(button.get_label())
                if self.entry.get_text() == 'error':
                    number = 0
                else:
                    number = int(self.entry.get_text())
                number = number * 10 + new_digit
                if self.counter == 0:
                    self.first_number = number
                else:
                    self.second_number = number
                self.entry.set_text(str(number))
    
        def do_operation(self):
            if self.operation == "plus":
                self.first_number += self.second_number
            elif self.operation == "minus":
                self.first_number -= self.second_number
            elif self.operation == "multiplication":
                self.first_number *= self.second_number
            elif self.operation == "division":
                try:
                    self.first_number /= self.second_number
                except ZeroDivisionError:
                    self.first_number = 0
                    self.second_number = 0
                    self.counter = 0
                    self.entry.set_text('error')
                    self.operation = ""
                    return
            else:
                self.first_number = 0
                self.second_number = 0
                self.counter = 0
                self.entry.set_text('error')
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Calculator", application=app)
            self.set_default_size(350, 200)
            self.set_border_width(10)
    
            # Vstupní pole
            self.entry = Gtk.Entry()
            # s počátečním textem
            self.entry.set_text('0')
            # zarovnaným doprava
            self.entry.set_alignment(1)
            # Text v poli nemůže bý změněn psaním
            self.entry.set_can_focus(False)
    
            # Mřížka
            grid = Gtk.Grid()
            grid.set_row_spacing(5)
    
            # do které se připojí vstupní pole
            grid.attach(self.entry, 0, 0, 1, 1)
    
            # Popisky pro tlačítka
            buttons = [7, 8, 9, '/',
                       4, 5, 6, '*',
                       1, 2, 3, '-',
                       'C', 0, '=', '+']
    
            # Každý z řádků je ButtonBox připojený do mřížky
            for i in range(4):
                hbox = Gtk.ButtonBox.new(Gtk.Orientation.HORIZONTAL)
                hbox.set_spacing(5)
                grid.attach(hbox, 0, i + 1, 1, 1)
                # Každý ButtonBox má 4 tlačíka napojená na funkci zpětného volání
                for j in range(4):
                    button = Gtk.Button(label=buttons[i * 4 + j])
                    button.set_can_focus(False)
                    button.connect("clicked", self.button_clicked)
                    hbox.add(button)
    
            # Pár proměnných pro výpočty
            self.first_number = 0
            self.second_number = 0
            self.counter = 0
            self.operation = ""
    
            # Přidá mřížku do okna
            self.add(grid)
    
        # Funkce zpětného volání pro všechna tlačítka
        def button_clicked(self, button):
            # Pro početní operace
            if button.get_label() == '+':
                self.counter += 1
                if self.counter &gt; 1:
                    self.do_operation()
                self.entry.set_text('0')
                self.operation = "plus"
            elif button.get_label() == '-':
                self.counter += 1
                if self.counter &gt; 1:
                    self.do_operation()
                self.entry.set_text('0')
                self.operation = "minus"
            elif button.get_label() == '*':
                self.counter += 1
                if self.counter &gt; 1:
                    self.do_operation()
                self.entry.set_text('0')
                self.operation = "multiplication"
            elif button.get_label() == '/':
                self.counter += 1
                if self.counter &gt; 1:
                    self.do_operation()
                self.entry.set_text('0')
                self.operation = "division"
            # Pro =
            elif button.get_label() == '=':
                self.do_operation()
                self.entry.set_text(str(self.first_number))
                self.counter = 1
            # Pro Zrušit
            elif button.get_label() == 'C':
                self.first_number = 0
                self.second_number = 0
                self.counter = 0
                self.entry.set_text('')
                self.operation = ""
            # Pro číslice
            else:
                new_digit = int(button.get_label())
                if self.entry.get_text() == 'error':
                    number = 0
                else:
                    number = int(self.entry.get_text())
                number = number * 10 + new_digit
                if self.counter == 0:
                    self.first_number = number
                else:
                    self.second_number = number
                self.entry.set_text(str(number))
    
        def do_operation(self):
            if self.operation == "plus":
                self.first_number += self.second_number
            elif self.operation == "minus":
                self.first_number -= self.second_number
            elif self.operation == "multiplication":
                self.first_number *= self.second_number
            elif self.operation == "division":
                try:
                    self.first_number /= self.second_number
                except ZeroDivisionError:
                    self.first_number = 0
                    self.second_number = 0
                    self.counter = 0
                    self.entry.set_text('error')
                    self.operation = ""
                    return
            else:
                self.first_number = 0
                self.second_number = 0
                self.counter = 0
                self.entry.set_text('error')
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a ButtonBox widget
cs: Užitečné metody pro widget ButtonBox

note: (itstool) path: item/p
en: The layout of the ButtonBox are set with <code>set_layout(layout)</code>, where <code>layout</code> can be <code>Gtk.ButtonBoxStyle.SPREAD</code> (buttons are evenly spread across the box), <code>Gtk.ButtonBoxStyle.EDGE</code> (buttons are placed at the edges of the box), <code>Gtk.ButtonBoxStyle.START</code> (buttons are grouped towards the start of the box), <code>Gtk.ButtonBoxStyle.END</code> (buttons are grouped towards the end of the box), <code>Gtk.ButtonBoxStyle.CENTER</code> (buttons are centered in the box).
cs: Rozvržení widgetu ButtonBox se nastavuje pomocí <code>set_layout(rozvržení)</code>, kde <code>rozvržení</code> může být <code>Gtk.ButtonBoxStyle.SPREAD</code> (tlačítka jsou v boxu rovnoměrně rozložená), <code>Gtk.ButtonBoxStyle.EDGE</code> (tlačítka jsou umístěna u hran boxu), <code>Gtk.ButtonBoxStyle.START</code> (tlačítka jsou seskupena na začátku boxu), <code>Gtk.ButtonBoxStyle.END</code> (tlačítka jsou seskupena na konci boxu), <code>Gtk.ButtonBoxStyle.CENTER</code> (tlačítka jsou na středu boxu).

note: (itstool) path: item/p
en: <code>set_child_secondary(button, is_secondary)</code> sets whether <code>button</code> should appear in a secondary group of children. A typical use of a secondary child is the help button in a dialog. This group appears after the other children if the style is <code>START</code>, <code>SPREAD</code> or <code>EDGE</code>, and before the other children if the style is <code>END</code>. If the style is <code>START</code> or <code>END</code>, then the secondary children are aligned at the other end of the button box from the main children. For the other styles, they appear immediately next to the main children.
cs: <code>set_child_secondary(tlačítko, je_druhé)</code> nastavuje, že <code>tlačítko</code> se má objevit v druhé skupině potomků. Typické použití jako druhého tlačítka je tlačítko nápověda v dialogovém okně. Tato skupina se objeví za ostatními potomky v případě, že styl je <code>START</code>, <code>SPREAD</code> or <code>EDGE</code>, a nebo před ostatními potomky, v případě že styl je <code>END</code>. Pokud je styl <code>START</code> nebo <code>END</code>, je druhý potomek zarovnán k opačnému konci tlačítkového boxu než hlavní potomek. Pro ostatní styly se objeví hned vedle hlavního potomka.

note: (itstool) path: item/p
en: <code>set_child_non_homogeneous(button, is_non_homogeneous)</code> sets whether the child is exempted from homogeneous sizing. Default value is <code>False</code>.
cs: <code>set_child_non_homogeneous(tlačítko, není_homogení)</code> nastavuje, že potomek je vynechán z homogenního nastavení velikosti. Výchozí hodnota je <code>False</code>.

note: (itstool) path: item/p
en: <code>set_spacing(spacing)</code> sets the spacing, in pixels, between the buttons of the box.
cs: <code>set_spacing(rozestup)</code> nastaví rozestup, v pixelech, mezi tlačítky v boxu.

note: (itstool) path: info/desc
en: Tutorials and code samples in C.
cs: Výuka a ukázky kódu v jazyce C.

note: (itstool) path: page/title
en: Platform Demos in C
cs: Demonstrace platformy v jazyce C

note: (itstool) path: section/title
en: Prerequisites
cs: Předpoklady

note: (itstool) path: section/p
en: To compile these platform demos you will need a C compiler, for example <link href="https://gcc.gnu.org/">gcc</link>. You will also need GTK+ 3 including headers and pkg-config files. Linux distributions usually abstract GTK+ 3 headers and pkg-config files into separate packages called <em>gtk3-devel</em>, <em>gtk3-dev</em> or similar.
cs: Ke kompilaci této ukázky budete potřebovat překladač jazyka C, například <link href="https://gcc.gnu.org/">gcc</link>. Dále budete potřebovat GTK+ 3, včetně hlavičkových souborů a souboru pkg-config. Linuxové distribuce zpravidla tyto soubory oddělují do zvláštních balíčků nazvaných <em>gtk3-devel</em>, <em>gtk3-dev</em> nebo tak nějak.

note: (itstool) path: section/title
en: Guidelines for new developers
cs: Příručka pro nové vývojáře

note: (itstool) path: section/p
en: Beyond the prerequisites mentioned above, several tools has been developed to assist you further in developing your GNOME application. GNOME also recommends a specific coding style and conventions which this section will elaborate further upon.
cs: Mimo výše uvedených předpokladů existuje i několik nástrojů, které byly vyvinuty za účelem pomáhat vám při vývoji vašich aplikací GNOME. GNOME také doporučuje konkrétní styl a konvence kódování, které rozebereme dále v této části.

note: (itstool) path: section/title
en: Recommended tools
cs: Doporučené nástroje

note: (itstool) path: item/p
en: <link href="https://wiki.gnome.org/Apps/Devhelp">DevHelp</link>: An API documentation browser for GNOME.
cs: <link href="https://wiki.gnome.org/Apps/Devhelp">DevHelp</link>: Prohlížeč dokumentace k API pro GNOME.

note: (itstool) path: item/p
en: A GNOME IDE (Integrated Development Environment). An IDE can assist you in writing and debugging C code, for example <link href="https://wiki.gnome.org/Apps/Builder">Builder</link> or <link href="https://wiki.gnome.org/Apps/Anjuta">Anjuta</link>.
cs: IDE (Integrated Development Environment) pro GNOME. IDE vás může navádět při psaní a ladění kódu v jazyce C, třeba <link href="https://wiki.gnome.org/Apps/Builder">Builder</link> nebo <link href="https://wiki.gnome.org/Apps/Anjuta">Anjuta</link>.

note: (itstool) path: item/p
en: <link href="http://glade.gnome.org/">Glade</link>: A user interface designer for GTK+ Applications.
cs: <link href="http://glade.gnome.org/">Glade</link>: Návrhář uživatelského rozhraní pro aplikace GTK+.

note: (itstool) path: item/p
en: An IRC Client, for example <link href="https://wiki.gnome.org/Apps/Polari">Polari</link> or <link href="https://wiki.gnome.org/Apps/Empathy">Empathy</link>. If you run into problems while following the beginner tutorials, join #gnome on <em>irc.gnome.org</em>.
cs: Klient IRC, například <link href="https://wiki.gnome.org/Apps/Polari">Polari</link> nebo <link href="https://wiki.gnome.org/Apps/Empathy">Empathy</link>. Když se při postupu podle lekce pro začátečníky dostanete do problémů, připojte se ke #gnome na <em>irc.gnome.org</em>.

note: (itstool) path: section/title
en: Coding Style
cs: Styl kódování

note: (itstool) path: section/p
en: Most applications in the GNOME project is written in the <link href="http://en.wikipedia.org/wiki/Indent_style#GNU_style">GNU style</link> of indentation. The tutorials and code examples presented are following this convention and you are recommended to do so too.
cs: Většina aplikací v projektu GNOME je napsána s odsazením ve <link href="http://en.wikipedia.org/wiki/Indent_style#GNU_style">stylu GNU</link>. Tyto lekce a příklady kódu jsou prezentovány s dodržením těchto konvencí a vám je doporučujeme také dodržovat.

note: (itstool) path: section/title
en: Executing Code
cs: Spuštění kódu

note: (itstool) path: item/p
en: Copy and paste the code into <var>filename</var>.c
cs: Zkopírujte a vložte kód do <var>název_souboru</var>.c

note: (itstool) path: item/screen
en: gcc <var>filename</var>.c `pkg-config --cflags --libs gtk+-3.0` -o <var>filename</var>
cs: gcc <var>název_souboru</var>.c `pkg-config --cflags --libs gtk+-3.0` -o <var>název_souboru</var>

note: (itstool) path: note/p
en: For more information about compiling GTK+ programs see <link href="http://developer.gnome.org/gtk3/3.4/gtk-compiling.html">Compiling GTK+ Applications on UNIX</link>.
cs: Více informací ohledně kompilování programů GTK+ viz <link href="http://developer.gnome.org/gtk3/3.4/gtk-compiling.html">Kompilování aplikací GTK+ v UNIXu</link>.

note: (itstool) path: section/title
en: Widget Code Examples
cs: Ukázka kódu widgetu

note: (itstool) path: info/desc
en: Create widgets with a discrete ToggleButton
cs: Vytvoří widget s dvoustavovým přepínacím tlačítkem

note: (itstool) path: page/p
en: This CheckButton toggles the title.
cs: Toto zaškrtávací políčko CheckButton přepíná nadpis.

note: (itstool) path: page/code
en: #include &lt;gtk/gtk.h&gt;
    
    /* signal handler for "toggled" signal of the CheckButton */
    static void
    toggled_cb (GtkToggleButton *toggle_button,
                gpointer         user_data)
    {
      GtkWindow *window = user_data;
    
      if (gtk_toggle_button_get_active (toggle_button))
          gtk_window_set_title (window, "CheckButton Example");
      else
          gtk_window_set_title (window, "");
    }
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *checkbutton;
    
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "CheckButton Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 300, 100);
    
      checkbutton = gtk_check_button_new_with_label ("Show Title");
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton), TRUE);
      g_signal_connect (GTK_TOGGLE_BUTTON (checkbutton), "toggled", G_CALLBACK (toggled_cb), window);
      gtk_container_add (GTK_CONTAINER (window), checkbutton);
      gtk_widget_show_all (window);
    }
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.example.checkbutton", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: #include &lt;gtk/gtk.h&gt;
    
    /* Zpracování signálu pro signál "toggled" widgetu CheckButton */
    static void
    toggled_cb (GtkToggleButton *toggle_button,
                gpointer         user_data)
    {
      GtkWindow *window = user_data;
    
      if (gtk_toggle_button_get_active (toggle_button))
          gtk_window_set_title (window, "CheckButton Example");
      else
          gtk_window_set_title (window, "");
    }
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *checkbutton;
    
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "CheckButton Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 300, 100);
    
      checkbutton = gtk_check_button_new_with_label ("Show Title");
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton), TRUE);
      g_signal_connect (GTK_TOGGLE_BUTTON (checkbutton), "toggled", G_CALLBACK (toggled_cb), window);
      gtk_container_add (GTK_CONTAINER (window), checkbutton);
      gtk_widget_show_all (window);
    }
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.example.checkbutton", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: info/desc
en: A box which can be checked or unchecked
cs: Políčko, které může být zaškrtnuté nebo nezaškrtnuté

note: (itstool) path: page/p
en: This application has a CheckButton. Whether the box is checked dictates whether the window's title bar shows anything.
cs: Tato aplikace má widget CheckButton. Je-li políčko zaškrtnuté, nebo ne, ovlivňuje, jestli je něco zobrazeno v záhlaví okna, nebo ne.

note: (itstool) path: page/p
en: A CheckButton sends the "toggled" signal when it's checked or unchecked. While it's checked, the "active" property is true. While it's not, "active" tests as false.
cs: Když políčko zaškrtnete nebo zaškrtnutí zrušíte, vyšle signál <code>"toggled"</code>. Když je zaškrtnuté, je vlastnost <code>"active"</code> nastavena na <code>true</code>. Když není, vrátí test této vlastnosti hodnotu <code>false</code>.

note: (itstool) path: section/title
en: Libraries to import
cs: Importované knihovny

note: (itstool) path: section/p
en: These are the libraries we need to import for this application to run. Remember that the line which tells GNOME that we're using Gjs always needs to go at the start.
cs: Toto jsou knihovny, které potřebujeme naimportovat, aby aplikace běžela. Pamatujte si, že řádek, který GNOME říká, že používáme Gjs, musí být vždy na začátku.

note: (itstool) path: section/title
en: Creating the application window
cs: Vytvoření okna aplikace

note: (itstool) path: section/code
en: 
    class CheckButtonExample {
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jscheckbutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Connect 'activate' and 'startup' signals to the callback functions
        this.application.connect('activate', this._onActivate.bind(this));
        this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI ();
        }
cs: 
    class CheckButtonExample {
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jscheckbutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
        this.application.connect('activate', this._onActivate.bind(this));
        this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate", která zobrazí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup", která sestaví uživatelské rozhraní
        _onStartup() {
            this._buildUI ();
        }

note: (itstool) path: section/p
en: All the code for this sample goes in the CheckButtonExample class. The above code creates a <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> for our widgets and window to go in.
cs: Všechen kód této ukázky je ve třídě <code>CheckButtonExample</code>. Výše uvedený kód vytvoří <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> pro naše widgety a okno, ve kterém budou.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 100,
                default_width: 300,
                border_width: 10,
                title: "CheckButton Example"});
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 100,
                default_width: 300,
                border_width: 10,
                title: "CheckButton Example"});

note: (itstool) path: section/p
en: The _buildUI function is where we put all the code to create the application's user interface. The first step is creating a new <link href="GtkApplicationWindow.js.page">Gtk.ApplicationWindow</link> to put all our widgets into.
cs: Funkce <code>_buildUI</code> je místo, ze kterého voláme všechen kód, který vytváří uživatelské rozhraní aplikace. Prvním krokem je vytvoření nového <link href="GtkApplicationWindow.js.page">Gtk.ApplicationWindow</link>, do kterého vložíme všechny naše widgety.

note: (itstool) path: section/title
en: Creating the checkbutton
cs: Vytvoření widgetu CheckButton

note: (itstool) path: section/code
en: 
            // Create the check button
            this._button = new Gtk.CheckButton ({label: "Show Title"});
            this._window.add (this._button);
    
            // Have the check button be checked by default
            this._button.set_active (true);
    
            // Connect the button to a function that does something when it's toggled
            this._button.connect ("toggled", this._toggledCB.bind(this));
cs: 
            // Vytvoří zaškrtávací políčko
            this._button = new Gtk.CheckButton ({label: "Show Title"});
            this._window.add (this._button);
    
            // Zajistí, že ve výchozím stavu bude zaškrtnuté
            this._button.set_active (true);
    
            // Napojí zaškrtávací políčko k funkci, která při přepnutí něco udělá
            this._button.connect ("toggled", this._toggledCB.bind(this));

note: (itstool) path: section/p
en: This code creates the checkbutton itself. The label next to the checkbutton is created by giving the checkbutton the "label" property and assigning a string value to it. Since this checkbutton toggles whether the window title is on or off, and the window title will be on to start with, we want the box to be checked by default. Whenever the user checks or unchecks the box, we call the _toggledCB function.
cs: Tento kód vytvoří vlastní zaškrtávací políčko. Popisek vedle něj je vytvořen udáním vlastnosti <code>label</code> zaškrtávacího políčka a přiřazením řetězcové hodnoty do něj. Protože toto zaškrtávací políčko přepíná, zda má okno v záhlaví název a na začátku jej má, chceme aby políčko bylo ve výchozím stavu zaškrtnuté. Kdykoliv uživatel jeho zaškrtnutí změní, zavolá se funkce <code>_toggledCB</code>.

note: (itstool) path: section/code
en: 
            // Show the window and all child widgets
            this._window.show_all();
        }
cs: 
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }

note: (itstool) path: section/p
en: This code finishes up creating the UI, by telling the window to show itself and all child widgets (which is just the checkbutton in this case).
cs: Tento kód dokončí vytváření uživatelského rozhraní tím, že řekne oknu, aby zobrazilo sebe a všechny své synovské widgety (což je v tomto případě jen zaškrtávací políčko).

note: (itstool) path: section/title
en: Function which handles the checkbutton's toggling
cs: Funkce, která zpracovává přepnutí zaškrtávacího políčka

note: (itstool) path: section/code
en: 
        _toggledCB() {
    
            // Make the window title appear or disappear when the checkbox is toggled
            if (this._button.get_active() == true)
                this._window.set_title ("CheckButton Example");
            else
                this._window.set_title ("");
    
        }
    
    };
cs: 
        _toggledCB() {
    
            // Zobrazí a skryje obsah záhlaví okna při přepnutí zaškrtávacího políčka
            if (this._button.get_active() == true)
                this._window.set_title ("CheckButton Example");
            else
                this._window.set_title ("");
    
        }
    
    };

note: (itstool) path: section/p
en: If the checkbutton is toggled from on to off, we want the window title to disappear. If it's toggled from off to on, we want it to reappear. We can tell which way it was toggled by testing to see whether it's active (checked) or not afterwards. A simple if / else statement which calls the checkbutton's get_active() method will work for this.
cs: Když se je zrušeno zaškrtnutí zaškrtávacího políčka, chceme aby zmizel název na záhlaví okna. Až je zase zaškrtnuto, chceme, aby se znovu objevil. To, v jakém je stavu, můžeme říci po otestování, jestli je aktivní (zaškrtnuté) nebo ne. K funkčnosti nám stačí jednoduchý výraz <code>if</code>/<code>else</code>, který zavolá metodu <code>get_active()</code> zaškrtávacího políčka.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new CheckButtonExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new CheckButtonExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished CheckButtonExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci výsledné třídy CheckButtonExample a aplikaci spustíme.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class CheckButtonExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jscheckbutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 100,
                default_width: 300,
                border_width: 10,
                title: "CheckButton Example"});
    
            // Create the check button
            this._button = new Gtk.CheckButton ({label: "Show Title"});
            this._window.add (this._button);
    
            // Have the check button be checked by default
            this._button.set_active (true);
    
            // Connect the button to a function that does something when it's toggled
            this._button.connect ("toggled", this._toggledCB.bind(this));
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _toggledCB() {
    
            // Make the window title appear or disappear when the checkbox is toggled
            if (this._button.get_active() == true)
                this._window.set_title ("CheckButton Example");
            else
                this._window.set_title ("");
    
        }
    
    };
    
    // Run the application
    let app = new CheckButtonExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class CheckButtonExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jscheckbutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 100,
                default_width: 300,
                border_width: 10,
                title: "CheckButton Example"});
    
            // Vytvoří zaškrtávací políčko
            this._button = new Gtk.CheckButton ({label: "Show Title"});
            this._window.add (this._button);
    
            // Zajistí, že ve výchozím stavu bude zaškrtnuté
            this._button.set_active (true);
    
            // Napojí zaškrtávací políčko k funkci, která při přepnutí něco udělá
            this._button.connect ("toggled", this._toggledCB.bind(this));
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        },
    
    
    
        _toggledCB: function () {
    
            // Zobrazí a skryje obsah záhlaví okna při přepnutí zaškrtávacího políčka
            if (this._button.get_active() == true)
                this._window.set_title ("CheckButton Example");
            else
                this._window.set_title ("");
    
        }
    
    };
    
    // Spustí aplikaci
    let app = new CheckButtonExample ();
    app.application.run (ARGV);

note: (itstool) path: section/title
en: In-depth documentation
cs: Dokumentace jdoucí do hloubky

note: (itstool) path: info/desc
en: A toggle button in a window
cs: Přepínací tlačítko v okně

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # a window
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="CheckButton Example", application=app)
            self.set_default_size(300, 100)
            self.set_border_width(10)
    
            # a new checkbutton
            button = Gtk.CheckButton()
            #  with a label
            button.set_label("Show Title")
            # connect the signal "toggled" emitted by the checkbutton
            # with the callback function toggled_cb
            button.connect("toggled", self.toggled_cb)
            # by default, the checkbutton is active
            button.set_active(True)
    
            # add the checkbutton to the window
            self.add(button)
    
        # callback function
        def toggled_cb(self, button):
            # if the togglebutton is active, set the title of the window
            # as "Checkbutton Example"
            if button.get_active():
                self.set_title("CheckButton Example")
            # else, set it as "" (empty string)
            else:
                self.set_title("")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # Okno
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="CheckButton Example", application=app)
            self.set_default_size(300, 100)
            self.set_border_width(10)
    
            # Nové zaškrtávací políčko
            button = Gtk.CheckButton()
            # s popiskem
            button.set_label("Show Title")
            # Napojí signál "toggled" vyslaní zaškrtávacím políčkem
            # na funkci zpětného volání toggled_cb
            button.connect("toggled", self.toggled_cb)
            # Ve výchozím stavu je zaškrtávací políčko aktivní
            button.set_active(True)
    
            # Přidá zaškrtávací políčko do okna
            self.add(button)
    
        # Funkce zpětného volání
        def toggled_cb(self, button):
            # Kdy je zaškrtávací políčko aktivní, nastaví název
            # okna na „Checkbutton Example“
            if button.get_active():
                self.set_title("CheckButton Example")
            # jinak je nastaví na prázdný řetězec
            else:
                self.set_title("")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a CheckButton widget
cs: Užitečné metody pro widget CheckButton

note: (itstool) path: section/p
en: In line 17 the <code>"toggled"</code> signal is connected to the callback function <code>toggled_cb()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 17 je signál <code>"toggled"</code> napojen na funkci zpětného volání <code>toggled_cb()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: info/desc
en: Create widgets with a discrete toggle button
cs: Vytvoří widget s dvoustavovým přepínacím tlačítkem

note: (itstool) path: page/code
en: /* A window in the application */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* The constructor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "CheckButton Example");
    
    		this.set_default_size (300, 100);
    		this.border_width = 10;
    
    		var checkbutton = new Gtk.CheckButton.with_label ("Show Title");
    
    		/* Connect the checkbutton to the
    		 * callback function (aka. signal handler).
    		 */
    		checkbutton.toggled.connect (this.toggled_cb);
    
    		/* Add the button to the this window */
    		this.add (checkbutton);
    
    		checkbutton.set_active (true);
    		checkbutton.show ();
    	}
    
    	/* The signal handler for the 'toggled' signal of the checkbutton. */
    	void toggled_cb (Gtk.ToggleButton checkbutton) {
    		if (checkbutton.get_active())
    			this.set_title ("CheckButton Example");
    		else
    			this.set_title ("");
    	}
    }
    
    /* This is the application */
    class MyApplication : Gtk.Application {
    
    	/* The constructor */
    	internal MyApplication () {
    		Object (application_id: "org.example.checkbutton");
    	}
    
    	/* Override the activate signal of GLib.Application */
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    }
    
    /* main creates and runs the application */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Okno v aplikaci */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* Konstruktor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "CheckButton Example");
    
    		this.set_default_size (300, 100);
    		this.border_width = 10;
    
    		var checkbutton = new Gtk.CheckButton.with_label ("Show Title");
    
    		/* Napojí zaškrtávací políčko na funci
    		 * zpětného volání (neboli obsluha signálu).
    		 */
    		checkbutton.toggled.connect (this.toggled_cb);
    
    		/* Přidá tlačítko do tohoto okna */
    		this.add (checkbutton);
    
    		checkbutton.set_active (true);
    		checkbutton.show ();
    	}
    
    	/* Zpracování signálu pro signál "toggled" zaškrtávacího políčka */
    	void toggled_cb (Gtk.ToggleButton checkbutton) {
    		if (checkbutton.get_active())
    			this.set_title ("CheckButton Example");
    		else
    			this.set_title ("");
    	}
    }
    
    /* Toto je aplikace */
    class MyApplication : Gtk.Application {
    
    	/* Konstruktor */
    	internal MyApplication () {
    		Object (application_id: "org.example.checkbutton");
    	}
    
    	/* Přepíše signál "activate" z GLib.Application */
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    }
    
    /* main vytvoří a spustí aplikaci */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: A button to launch a color selection dialog
cs: Tlačítko, které zobrazí dialogové okno pro výběr barvy

note: (itstool) path: page/p
en: This ColorButton launches a color selection dialog and prints in the terminal the RGB values of the color selected.
cs: ColorButton spustí dialogové okno pro výběr barvy a vypíše do terminálu hodnoty RGB vybrané barvy.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gdk = '3.0';
    imports.gi.versions.Gtk = '3.0';
    
    const Gdk = imports.gi.Gdk;
    const GObject = imports.gi.GObject;
    const Gtk = imports.gi.Gtk;
    
    class ColorbuttonExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application ({ application_id: 'org.example.jscolorbutton' });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this.window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this.window = new Gtk.ApplicationWindow ({ application: this.application,
                                                       window_position: Gtk.WindowPosition.CENTER,
                                                       title: "ColorButton",
                                                       default_width: 150,
                                                       default_height: 50,
                                                       border_width: 10 });
    
            this.button = new Gtk.ColorButton();
            this.color = new Gdk.RGBA();
            this.color.red = 0.0;
            this.color.green = 0.0;
            this.color.blue = 1.0;
            this.color.alpha = 0.5;
            this.button.set_rgba(this.color);
            this.button.connect("color-set", this.onColorChosen.bind(this));
            this.label = new Gtk.Label();
            this.label.set_text("Click to choose a color");
    
            let grid = new Gtk.Grid();
            grid.attach(this.button, 0, 0, 2, 1);
            grid.attach(this.label, 0, 1, 2, 1);
            this.window.add(grid);
            this.window.show_all();
        }
    
        onColorChosen() {
            let colorName = this.color.to_string();
            this.label.set_text("You chose the color " + colorName);
        }
    };
    
    // Run the application
    let app = new ColorbuttonExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gdk = '3.0';
    imports.gi.versions.Gtk = '3.0';
    
    const Gdk = imports.gi.Gdk;
    const GObject = imports.gi.GObject;
    const Gtk = imports.gi.Gtk;
    
    class ColorbuttonExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application ({ application_id: 'org.example.jscolorbutton' });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this.window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this.window = new Gtk.ApplicationWindow ({ application: this.application,
                                                       window_position: Gtk.WindowPosition.CENTER,
                                                       title: "ColorButton",
                                                       default_width: 150,
                                                       default_height: 50,
                                                       border_width: 10 });
    
            this.button = new Gtk.ColorButton();
            this.color = new Gdk.RGBA();
            this.color.red = 0.0;
            this.color.green = 0.0;
            this.color.blue = 1.0;
            this.color.alpha = 0.5;
            this.button.set_rgba(this.color);
            this.button.connect("color-set", this.onColorChosen.bind(this));
            this.label = new Gtk.Label();
            this.label.set_text("Click to choose a color");
    
            let grid = new Gtk.Grid();
            grid.attach(this.button, 0, 0, 2, 1);
            grid.attach(this.label, 0, 1, 2, 1);
            this.window.add(grid);
            this.window.show_all();
        }
    
        onColorChosen() {
            let colorName = this.color.to_string();
            this.label.set_text("You chose the color " + colorName);
        }
    };
    
    // Spustí aplikaci
    let app = new ColorbuttonExample ();
    app.application.run (ARGV);

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/gdk3/stable/gdk3-RGBA-Colors.html">RGBA Colors</link>
cs: <link href="http://developer.gnome.org/gdk3/stable/gdk3-RGBA-Colors.html">Barvy RGBA</link>

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Gdk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="ColorButton", application=app)
            self.set_default_size(150, 50)
            self.set_border_width(10)
    
            # a colorbutton (which opens a dialogue window in
            # which we choose a color)
            self.button = Gtk.ColorButton()
            # with a default color (blue, in this instance)
            color = Gdk.RGBA()
            color.red = 0.0
            color.green = 0.0
            color.blue = 1.0
            color.alpha = 0.5
            self.button.set_rgba(color)
    
            # choosing a color in the dialogue window emits a signal
            self.button.connect("color-set", self.on_color_chosen)
    
            # a label
            label = Gtk.Label()
            label.set_text("Click to choose a color")
    
            # a grid to attach button and label
            grid = Gtk.Grid()
            grid.attach(self.button, 0, 0, 2, 1)
            grid.attach(label, 0, 1, 2, 1)
            self.add(grid)
    
        # if a new color is chosen, we print it as rgb(r,g,b) in the terminal
        def on_color_chosen(self, user_data):
            print("You chose the color: " + self.button.get_rgba().to_string())
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Gdk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="ColorButton", application=app)
            self.set_default_size(150, 50)
            self.set_border_width(10)
    
            # ColorButton (které otevře dialogové okno, ve
            # kterém si vybíráme barvu)
            self.button = Gtk.ColorButton()
            # s výchozí barvou (v tomto případě modrou)
            color = Gdk.RGBA()
            color.red = 0.0
            color.green = 0.0
            color.blue = 1.0
            color.alpha = 0.5
            self.button.set_rgba(color)
    
            # Výběr barvy v dialogovém okně vyšle signál
            self.button.connect("color-set", self.on_color_chosen)
    
            # Popisek
            label = Gtk.Label()
            label.set_text("Click to choose a color")
    
            # Mřížka pro připojení tlačítka a popisku
            grid = Gtk.Grid()
            grid.attach(self.button, 0, 0, 2, 1)
            grid.attach(label, 0, 1, 2, 1)
            self.add(grid)
    
        # Když je vybrána nová barva, vypíše ji ve formátu rgb(r,g,b) v terminálu
        def on_color_chosen(self, user_data):
            print("You chose the color: " + self.button.get_rgba().to_string())
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a ColorButton widget
cs: Užitečné metody pro widget ColorButton

note: (itstool) path: section/p
en: <code>set_color(color)</code>, where the <code>color</code> is defined as in the example, sets the color of the ColorButton, which by default is black. <code>get_color()</code> returns the color.
cs: <code>set_color(barva)</code>, kde <code>barva</code> je definována tak, jako v tomto příkladu, nastaví barvu u widgetu ColorButton. Výchozí barva je černá. <code>get_color()</code> vrátí aktuální barvu.

note: (itstool) path: section/p
en: In line 23 the <code>"color-set"</code> signal is connected to the callback function <code>on_color_chosen()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 23 je signál <code>"color-set"</code> napojen na funkci zpětného volání <code>on_color_chosen()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: page/p
en: RGB values of the selected color are shown in the label.
cs: Hodnoty RGB vybrané barvy se zobrazí v popisku.

note: (itstool) path: page/code
en: /* This is the application. */
    public class MyApplication : Gtk.Application {
    	Gtk.Label label;
    
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    		/* Create the window of this application and show it. */
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "ColorButton";
    		window.set_default_size (150, 50);
    		window.set_border_width (10);
    
    		/* Create a new ColorButton with default blue. */
    		var blue = Gdk.RGBA ();
    		blue.parse ("blue");
    		var colorbutton = new Gtk.ColorButton.with_rgba (blue);
    
    		label = new Gtk.Label ("Click to choose a color");
    
    		var grid = new Gtk.Grid ();
    		grid.attach (colorbutton, 0, 0, 1, 1);
    		grid.attach_next_to (label, colorbutton, Gtk.PositionType.BOTTOM, 1, 1);
    
    		colorbutton.color_set.connect (this.on_color_set);
    
    		window.add (grid);
    		window.show_all ();
    	}
    
    	void on_color_set (Gtk.ColorButton button) {
    		var color =  button.get_rgba ();
    		label.set_text ("RGBA: " + color.to_string());
    	}
    }
    
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Toto je aplikace. */
    public class MyApplication : Gtk.Application {
    	Gtk.Label label;
    
    	/* Přepíše signál "activate" z GLib.Application. */
    	protected override void activate () {
    		/* Vytvoří okno této aplikace a zobrazí jej. */
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "ColorButton";
    		window.set_default_size (150, 50);
    		window.set_border_width (10);
    
    		/* Vytvoří nové ColorButton s výchozí modrou. */
    		var blue = Gdk.RGBA ();
    		blue.parse ("blue");
    		var colorbutton = new Gtk.ColorButton.with_rgba (blue);
    
    		label = new Gtk.Label ("Click to choose a color");
    
    		var grid = new Gtk.Grid ();
    		grid.attach (colorbutton, 0, 0, 1, 1);
    		grid.attach_next_to (label, colorbutton, Gtk.PositionType.BOTTOM, 1, 1);
    
    		colorbutton.color_set.connect (this.on_color_set);
    
    		window.add (grid);
    		window.show_all ();
    	}
    
    	void on_color_set (Gtk.ColorButton button) {
    		var color =  button.get_rgba ();
    		label.set_text ("RGBA: " + color.to_string());
    	}
    }
    
    /* main vytvoří a spustí aplikaci. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: A text-only drop-down menu
cs: Čistě textová rozbalovací nabídka

note: (itstool) path: page/p
en: A ComboBox is a drop-down menu. The difference between a <link xref="combobox.js">ComboBox</link> and a ComboBoxText is that a ComboBoxText just has basic text options, while a full ComboBox uses a ListStore or TreeStore (which are basically spreadsheets) to show things like branching options, or pictures to go alongside each choice.
cs: <code>ComboBox</code> je rozbalovací nabídka. Rozdíl mezi <link xref="combobox.js">ComboBox</link> a <code>ComboBoxText</code> (textová rozbalovací nabídka) je v tom, že má jen základní textové volby, zatímco plnohodnotný <code>ComboBox</code> používá <code>ListStore</code> nebo <code>TreeStore</code> (což jsou v podstatě tabulky) k zobrazení věcí, jako jsou rozvětvené volby nebo obrázky vedle jednotlivých voleb.

note: (itstool) path: note/p
en: Unless you need the added features of a full ComboBox, or are comfortable working with ListStores and TreeStores, you may find it a lot simpler to use a ComboBoxText whenever possible.
cs: Pokud nepotřebujete přidané funkce plného <code>ComboBox</code> nebo komfort práce s <code>ListStore</code> a <code>TreeStore</code>, můžete shledat jednodušším, kdykoliv to použití dovolí, <code>ComboBoxText</code>.

note: (itstool) path: section/code
en: 
    const ComboBoxTextExample = new Lang.Class ({
        Name: 'ComboBoxText Example',
    
        // Create the application itself
        _init: function () {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jscomboboxtext'});
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', Lang.bind(this, this._onActivate));
            this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate: function () {
            this._window.present ();
        },
    
        // Callback function for 'startup' signal builds the UI
        _onStartup: function () {
            this._buildUI ();
        },
cs: 
    const ComboBoxTextExample = new Lang.Class ({
        Name: 'ComboBoxText Example',
    
        // Vytvoří vlastní aplikaci
        _init: function () {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jscomboboxtext'});
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', Lang.bind(this, this._onActivate));
            this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate: function () {
            this._window.present ();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function () {
            this._buildUI ();
        },

note: (itstool) path: section/p
en: All the code for this sample goes in the MessageDialogExample class. The above code creates a <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> for our widgets and window to go in.
cs: Všechen kód této ukázky je ve třídě <code>MessageDialogExample</code>. Výše uvedený kód vytvoří <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> pro naše widgety a okno, ve kterém budou.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI: function () {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_width: 200,
                border_width: 10 });
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function () {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_width: 200,
                border_width: 10 });

note: (itstool) path: section/p
en: The _buildUI function is where we put all the code to create the application's user interface. The first step is creating a new <link xref="GtkApplicationWindow.js">Gtk.ApplicationWindow</link> to put all our widgets into.
cs: Funkce <code>_buildUI</code> je místo, ze kterého voláme všechen kód, který vytváří uživatelské rozhraní aplikace. Prvním krokem je vytvoření nového <link xref="GtkApplicationWindow.js">Gtk.ApplicationWindow</link>, do kterého vložíme všechny naše widgety.

note: (itstool) path: section/title
en: Creating the ComboBoxText
cs: Vytvoření ComboBoxText

note: (itstool) path: section/code
en: 
            // Create the combobox
            this._comboBoxText = new Gtk.ComboBoxText();
    
            // Populate the combobox
            let distros = ["Select distribution", "Fedora", "Mint", "Suse"];
            for (let i = 0; i &lt; distros.length; i++)
                this._comboBoxText.append_text (distros[i]);
            this._comboBoxText.set_active (0);
    
            // Connect the combobox's 'changed' signal to our callback function
            this._comboBoxText.connect ('changed', Lang.bind (this, this._onComboChanged));
cs: 
            // Vytvoří rozbalovací seznam
            this._comboBoxText = new Gtk.ComboBoxText();
    
            // Naplní rozbalovací seznam
            let distros = ["Select distribution", "Fedora", "Mint", "Suse"];
            for (let i = 0; i &lt; distros.length; i++)
                this._comboBoxText.append_text (distros[i]);
            this._comboBoxText.set_active (0);
    
            // Napojí signál "changed" od rozbalovacího seznamu k naší funkci zpětnoho volání
            this._comboBoxText.connect ('changed', Lang.bind (this, this._onComboChanged));

note: (itstool) path: section/p
en: After we create the ComboBoxText, we use its <file>append_text</file> method to add text strings to it. Like the entries in an array, they each have a number for an ID, starting with 0. To make things simpler, you can actually create an array for your ComboBoxText entries, then use a for loop to append them in order, like we did here.
cs: Po té, co jsme vytvořili textový rozbalovací seznam, použijeme jeho metodu <code>append_text</code> pro přidání textových řetězců. Podobně jako u položek v poli má každá číslo ID, počínaje od 0. Pro zjednodušení můžete skutečně vytvořit pole a použít smyčku pro přidání jednotlivých položek tak, jako jsme to udělali zde.

note: (itstool) path: section/p
en: After we populate the ComboBoxText, we set its first entry to be active, so that we'll see the "Select distribution" line before we click on it. Then we connect its <file>changed</file> signal to the _onComboChanged function, so that it's called whenever you make a new selection from the drop-down menu.
cs: Až máme textový rozbalovací seznam naplněný, nastavíme jeho první položku jako aktivní, takže před prvním kliknutím uvidíme řádek „Select distribution“ („Vyberte distribuci“). Následně napojíme signál <code>"changed"</code> na funkci <code>_onComboChanged</code>, takže bude zavolána pokaždé, když je v rozbalovacím seznamu proveden nový výběr.

note: (itstool) path: note/p
en: If you'd like to add an entry to a ComboBoxText, you can use the <file>insert_text</file> method. And if you'd rather use a text string as an ID for each entry than rely on numbers alone, you can use the <file>append</file> and <file>insert</file> methods. See the links at the bottom of this tutorial for the details of how to use them.
cs: Když byste chtěli do <code>ComboBoxText</code> dodatečně přidat položku, můžete použít metodu <code>insert_text</code>. A pokud byste raději než čísla použili textové řetězce jako ID pro jednotlivé položky, můžete použít metody <code>append</code> a <code>insert</code>. Ohledně podrobností, jak je použít, se podívejte na odkazy ve spodní části této lekce.

note: (itstool) path: section/code
en: 
            // Add the combobox to the window
            this._window.add (this._comboBoxText);
    
            // Show the window and all child widgets
            this._window.show_all();
        },
cs: 
            // Přidá rozbalovací seznam do okna
            this._window.add (this._comboBoxText);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        },

note: (itstool) path: section/p
en: Finally, we add the ComboBoxText to the window, and tell the window to show itself and the widget inside it.
cs: Nakonec přidáme ComboBoxText do okna a oknu řekneme, aby zobrazilo sebe i widgety v něm.

note: (itstool) path: section/title
en: Function which handles your selection
cs: Funkce, která zpracovává váš výběr

note: (itstool) path: section/code
en: 
        _onComboChanged: function () {
    
            // The responses we'll use for our messagedialog
            let responses = ["",
                "Fedora is a community distro sponsored by Red Hat.",
                "Mint is a popular distro based on Ubuntu.",
                "SUSE is a name shared by two separate distros."];
cs: 
        _onComboChanged: function () {
    
            // Reakce, které použijeme v našem dialogovém okně se zprávou
            let responses = ["",
                "Fedora is a community distro sponsored by Red Hat.",
                "Mint is a popular distro based on Ubuntu.",
                "SUSE is a name shared by two separate distros."];

note: (itstool) path: section/p
en: We're going to create a pop-up <link xref="messagedialog.js">MessageDialog</link>, which shows you a message based on which distro you select. First, we create the array of responses to use. Since the first string in our ComboBoxText is just the "Select distribution" message, we make the first string in our array blank.
cs: Budeme vytvářet vyskakovací <link xref="messagedialog.js">MessageDialog</link>, který vám zobrazí zprávu podle vybrané distribuce. Nejdříve vytvoříme pole odpovědí, které se budou používat. Protože první položkou v našem rozbalovacím seznamu je jen informace „Select distribution“, ponecháme první řetězec v našem poli prázdný.

note: (itstool) path: section/code
en: 
            // Which combobox item is active?
            let activeItem = this._comboBoxText.get_active();
    
            // No messagedialog if you chose "Select distribution"
            if (activeItem != 0) {
                this._popUp = new Gtk.MessageDialog ({
                    transient_for: this._window,
                    modal: true,
                    buttons: Gtk.ButtonsType.OK,
                    message_type: Gtk.MessageType.INFO,
                    text: responses[activeItem]});
    
                // Connect the OK button to a handler function
                this._popUp.connect ('response', Lang.bind (this, this._onDialogResponse));
    
                // Show the messagedialog
                this._popUp.show();
            }
    
        },
cs: 
            // Která položka rozbalovacího seznamu je aktivní?
            let activeItem = this._comboBoxText.get_active();
    
            // Žádné dialogové okno se zprávou, když je vybráno „Select distribution“
            if (activeItem != 0) {
                this._popUp = new Gtk.MessageDialog ({
                    transient_for: this._window,
                    modal: true,
                    buttons: Gtk.ButtonsType.OK,
                    message_type: Gtk.MessageType.INFO,
                    text: responses[activeItem]});
    
                // Napojí tlačítko OK na obslušnou funkci
                this._popUp.connect ('response', Lang.bind (this, this._onDialogResponse));
    
                // Zobrazí dialogové okno se zprávou
                this._popUp.show();
            }
    
        },

note: (itstool) path: section/p
en: Before showing a MessageDialog, we first test to make sure you didn't choose the "Select distribution" message. After that, we set its text to be the entry in the array that corresponds to the active entry in our ComboBoxText. We do that using the <file>get_active</file> method, which returns the number ID of your selection.
cs: Než zobrazíme dialogové okno se zprávou, nejprve otestujeme, že není vybrána volba „Select distribution“. Po té nastavíme text podle položky v poli, která odpovídá aktivní položce v rozbalovacím seznamu. To uděláme pomocí metody <code>get_active</code> method, která vrací číselné ID vašeho výběru.

note: (itstool) path: note/p
en: Other methods you can use include <file>get_active_id,</file> which returns the text ID assigned by <file>append,</file> and <file>get_active_text,</file> which returns the full text of the string you selected.
cs: Jinými metodami, které bychom mohli použít jsou <code>get_active_id</code>, která vrací textové ID přiřazené metodou <code>append</code>, a <code>get_active_text</code>, která vrací celý text ve vybrané položce.

note: (itstool) path: section/p
en: After we create the MessageDialog, we connect its response signal to the _onDialogResponse function, then tell it to show itself.
cs: Po té, co vytvoříme <code>MessageDialog</code>, napojíme jeho signál <code>"response"</code> na funkci <code>_onDialogResponse</code> a následně řekneme oknu, ať se zobrazí.

note: (itstool) path: section/p
en: Since the only button the MessageDialog has is an OK button, we don't need to test its response_id to see which button was clicked. All we do here is destroy the popup.
cs: Protože jediným tlačítkem, které dialogové okno se zprávou má, je tlačítko <gui>OK</gui>, nepotřebujeme testovat hodnotu <code>response_id</code>, abychom zjistili, na které tlačítko bylo kliknuto. Vše, co uděláme, je, že dialogové okno zlikvidujeme.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new ComboBoxTextExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new ComboBoxTextExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished ComboBoxTextExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci konečné třídy ComboBoxTextExample a aplikaci spustíme.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    class ComboBoxTextExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jscomboboxtext'});
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present ();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_width: 200,
                border_width: 10 });
    
            // Create the combobox
            this._comboBoxText = new Gtk.ComboBoxText();
    
            // Populate the combobox
            let distros = ["Select distribution", "Fedora", "Mint", "Suse"];
            for (let i = 0; i &lt; distros.length; i++)
                this._comboBoxText.append_text (distros[i]);
            this._comboBoxText.set_active (0);
    
            // Connect the combobox's 'changed' signal to our callback function
            this._comboBoxText.connect ('changed', this._onComboChanged.bind(this));
    
            // Add the combobox to the window
            this._window.add (this._comboBoxText);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _onComboChanged() {
    
            // The responses we'll use for our messagedialog
            let responses = ["",
                "Fedora is a community distro sponsored by Red Hat.",
                "Mint is a popular distro based on Ubuntu.",
                "SUSE is a name shared by two separate distros."];
    
            // Which combobox item is active?
            let activeItem = this._comboBoxText.get_active();
    
            // No messagedialog if you chose "Select distribution"
            if (activeItem != 0) {
                this._popUp = new Gtk.MessageDialog ({
                    transient_for: this._window,
                    modal: true,
                    buttons: Gtk.ButtonsType.OK,
                    message_type: Gtk.MessageType.INFO,
                    text: responses[activeItem]});
    
                // Connect the OK button to a handler function
                this._popUp.connect ('response', this._onDialogResponse.bind(this));
    
                // Show the messagedialog
                this._popUp.show();
            }
    
        }
    
        _onDialogResponse() {
    
            this._popUp.destroy ();
    
        }
    
    };
    
    // Run the application
    let app = new ComboBoxTextExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    class ComboBoxTextExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jscomboboxtext'});
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present ();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_width: 200,
                border_width: 10 });
    
            // Vytvoří rozbalovací seznam
            this._comboBoxText = new Gtk.ComboBoxText();
    
            // Naplní rozbalovací seznam
            let distros = ["Select distribution", "Fedora", "Mint", "Suse"];
            for (let i = 0; i &lt; distros.length; i++)
                this._comboBoxText.append_text (distros[i]);
            this._comboBoxText.set_active (0);
    
            // Napojí signál "changed" od rozbalovacího seznamu k naší funkci zpětnoho volání
            this._comboBoxText.connect ('changed', this._onComboChanged.bind(this));
    
            // Přidá rozbalovací seznam do okna
            this._window.add (this._comboBoxText);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _onComboChanged() {
    
            // Reakce, které použijeme v našem dialogovém okně se zprávou
            let responses = ["",
                "Fedora is a community distro sponsored by Red Hat.",
                "Mint is a popular distro based on Ubuntu.",
                "SUSE is a name shared by two separate distros."];
    
            // Která položka rozbalovacího seznamu je aktivní?
            let activeItem = this._comboBoxText.get_active();
    
            // Žádné dialogové okno se zprávou, když je vybráno „Select distribution“
            if (activeItem != 0) {
                this._popUp = new Gtk.MessageDialog ({
                    transient_for: this._window,
                    modal: true,
                    buttons: Gtk.ButtonsType.OK,
                    message_type: Gtk.MessageType.INFO,
                    text: responses[activeItem]});
    
                // Napojí tlačítko OK na obslušnou funkci
                this._popUp.connect ('response', this._onDialogResponse.bind(this));
    
                // Zobrazí dialogové okno se zprávou
                this._popUp.show();
            }
    
        }
    
        _onDialogResponse() {
    
            this._popUp.destroy ();
    
        }
    
    };
    
    // Spustí aplikaci
    let app = new ComboBoxTextExample ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: A widget used to choose from a list of items
cs: Widget, který se používá k výběru položek ze seznamu.

note: (itstool) path: page/p
en: This ComboBox prints to the terminal when you change your selection.
cs: Tento rozbalovací seznam vypisuje změnu svého stavu do terminálu.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    /* This is the callback function. It is a handler function which reacts to the
     * signal. In this case, if the row selected is not the first one of the
     * ComboBox, we write its value in the terminal for the user.
     */
    static void
    on_changed (GtkComboBox *widget,
                gpointer   user_data)
    {
      GtkComboBox *combo_box = widget;
    
      if (gtk_combo_box_get_active (combo_box) != 0) {
        gchar *distro = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(combo_box));
        g_print ("You chose %s\n", distro);
        g_free (distro);
      }
    
    }
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      gint i;
      GtkWidget *view;
      GtkWidget *window;
      GtkWidget *combo_box;
    
      /* Create a window with a title, border width, and a default size. Setting the
       * size to -1 means to use the "natural" default size.
       * (the size request of the window)
       */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Welcome to GNOME");
      gtk_window_set_default_size (GTK_WINDOW (window), 200, -1);
      gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
    
      /* Create the combo box and append your string values to it. */
      combo_box = gtk_combo_box_text_new ();
      const char *distros[] = {"Select distribution", "Fedora", "Mint", "Suse"};
    
     
      /* G_N_ELEMENTS is a macro which determines the number of elements in an array.*/ 
      for (i = 0; i &lt; G_N_ELEMENTS (distros); i++){
      	gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), distros[i]);
      }
    
      /* Choose to set the first row as the active one by default, from the beginning */
      gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0);
    
      /* Connect the signal emitted when a row is selected to the appropriate
       * callback function.
       */
      g_signal_connect (combo_box,
                        "changed",
                        G_CALLBACK (on_changed),
                        NULL);
    
      /* Add it to the window */
      gtk_container_add (GTK_CONTAINER (window), combo_box);
    
      gtk_widget_show_all (window);
    }
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    /* Toto je funkce zpětného volání. Jedná se o zpracující funkci, která 
     * reaguje na signál. V tomto případě, když vybraný řádek není prvním 
     * řádkem v seznamu, vypíšem uživateli jeho hodnotu do terminálu.
     */
    static void
    on_changed (GtkComboBox *widget,
                gpointer   user_data)
    {
      GtkComboBox *combo_box = widget;
    
      if (gtk_combo_box_get_active (combo_box) != 0) {
        gchar *distro = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(combo_box));
        g_print ("You chose %s\n", distro);
        g_free (distro);
      }
    
    }
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      gint i;
      GtkWidget *view;
      GtkWidget *window;
      GtkWidget *combo_box;
    
      /* Vytvoří okno s názvem, šířkou okraje a výchozí velikostí. Nastavení 
       * velikosti na -1 znamená, že se má použít „přirozená“ výchozí velikost.
       * (velikost požadovaná oknem)
       */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Welcome to GNOME");
      gtk_window_set_default_size (GTK_WINDOW (window), 200, -1);
      gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
    
      /* Vytvoří rozbalovací seznam a připojí do něj řetězcové hodnoty. */
      combo_box = gtk_combo_box_text_new ();
      const char *distros[] = {"Select distribution", "Fedora", "Mint", "Suse"};
    
     
      /* G_N_ELEMENTS je makro, které určuje počet prvků v poli. */ 
      for (i = 0; i &lt; G_N_ELEMENTS (distros); i++){
      	gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), distros[i]);
      }
    
      /* Zvolí, že chceme ve výchozím stavu nastavit jako aktivní první řádek od začátku */
      gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0);
    
      /* Připojí signál, který je vyslán při výběru řádku, k příslušné 
       * funkci zpětného volání.
       */
      g_signal_connect (combo_box,
                        "changed",
                        G_CALLBACK (on_changed),
                        NULL);
    
      /* Přidá rozbalovací seznam do okna */
      gtk_container_add (GTK_CONTAINER (window), combo_box);
    
      gtk_widget_show_all (window);
    }
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: info/desc
en: A customizable drop-down menu
cs: Přizpůsobitelná rozbalovací nabídka

note: (itstool) path: page/p
en: A ComboBox is an extremely customizable drop-down menu. It holds the equivalent of a <link xref="treeview_simple_liststore.js">TreeView</link> widget that appears when you click on it, complete with a ListStore (basically a spreadsheet) that says what's in the rows and columns. In this example, our ListStore has the name of each option in one column, and the name of a stock icon in the other, which the ComboBox then turns into an icon for each option.
cs: <code>ComboBox</code> (rozbalovací seznam) je vysoce přizpůsobitelná rozbalovací nabídka. Obsahuje obdobu widgetu <link xref="treeview_simple_liststore.js">TreeView</link>, který se objeví po kliknutí, doplněného modelem <code>ListStore</code> (což je v zásadě tabulka), který udává, co se nachází v řádcích a sloupcích. V tomto příkladu má náš <code>ListStore</code> v jednom sloupci název volby a v druhém název standardní ikony, který je v rozbalovacím seznamu přeměněn na ikonu u každé z voleb.

note: (itstool) path: page/p
en: You select a whole horizontal row at a time, so the icons aren't treated as separate options. They and the text beside them make up each option you can click on.
cs: Vybíráte celý řádek naráz, takže ikona není oddělenou volbou. Ona a text vedle ní tvoří jednu volbu, na kterou můžete kliknout.

note: (itstool) path: note/p
en: Working with a ListStore can be time-consuming. If you just want a simple text-only drop-down menu, take a look at the <link xref="comboboxtext.js">ComboBoxText</link>. It doesn't take as much time to set up, and is easier to work with.
cs: Práce s <code>ListStore</code> zabere nějaký čas. Jestli chcete jen jednoduchou čistě textovou rozbalovací nabídku, podívejte se na <link xref="comboboxtext.js">ComboBoxText</link>. Jeho vytvoření nezabere tolik času a jednodušeji se s ním pracuje.

note: (itstool) path: section/code
en: 
    class ComboBoxExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jscombobox'});
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present ();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI ();
        }
cs: 
    class ComboBoxExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jscombobox'});
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate", která zobrazí okno při aktivaci
        _onActivate() {
            this._window.present ();
        }
    
        // Funkce zpětného volání pro signál "startup", která sestaví uživatelské rozhraní
        _onStartup() {
            this._buildUI ();
        }

note: (itstool) path: section/p
en: All the code for this sample goes in the ComboBoxExample class. The above code creates a <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> for our widgets and window to go in.
cs: Všechen kód této ukázky je ve třídě <code>ComboBoxExample</code>. Výše uvedený kód vytvoří <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> pro naše widgety a okno, ve kterém budou.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_width: 200,
                border_width: 10 });
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_width: 200,
                border_width: 10 });

note: (itstool) path: section/title
en: Creating the ListStore
cs: Vytvoření ListStore

note: (itstool) path: section/code
en: 
            // Create the liststore to put our options in
            this._listStore = new Gtk.ListStore();
            this._listStore.set_column_types ([
                GObject.TYPE_STRING,
                GObject.TYPE_STRING]);
cs: 
            // Vytvoří ListStore pro vložení našich voleb
            this._listStore = new Gtk.ListStore();
            this._listStore.set_column_types ([
                GObject.TYPE_STRING,
                GObject.TYPE_STRING]);

note: (itstool) path: section/p
en: This ListStore works like the one used in the <link xref="treeview_simple_liststore.js">TreeView</link> example. We're giving it two columns, both strings, because one of them will contain the names of <link href="https://developer.gnome.org/gtk3/3.4/gtk3-Stock-Items.html">stock Gtk icons</link>.
cs: ListStore funguje podobně, jako ten použitý v příkladu <link xref="treeview_simple_liststore.js">TreeView</link>. Dáme mu dva sloupce, oba řetězcové, přičemž jeden z nich bude obsahovat názvy <link href="https://developer.gnome.org/gtk3/3.4/gtk3-Stock-Items.html">standardních ikon Gtk</link>.

note: (itstool) path: section/p
en: If we'd wanted to use our own icons that weren't already built in to GNOME, we'd have needed to use the <file>gtk.gdk.Pixbuf</file> type instead. Here are a few other types you can use:
cs: Pokud byste chtěli použít své vlastní ikony, protože nechcete ty zabudované v GNOME, museli byste místo toho použít <file>gtk.gdk.Pixbuf</file>. Zde je pár dalších typů, které můžete použít:

note: (itstool) path: item/p
en: <file>GObject.TYPE_BOOLEAN</file> -- True or false
cs: <file>GObject.TYPE_BOOLEAN</file> – Pravda nebo nepravda

note: (itstool) path: item/p
en: <file>GObject.TYPE_FLOAT</file> -- A floating point number (one with a decimal point)
cs: <file>GObject.TYPE_FLOAT</file> – Desetinné číslo (tj. s plovoucí desetinou čárkou, resp. tečkou)

note: (itstool) path: item/p
en: <file>GObject.TYPE_STRING</file> -- A string of letters and numbers
cs: <file>GObject.TYPE_STRING</file> – Řetězec písmen a číslic

note: (itstool) path: note/p
en: You need to put the line <file>const GObject = imports.gi.GObject;</file> at the start of your application's code, like we did in this example, if you want to be able to use GObject types.
cs: Abyste mohli používat typy GObject, potřebujete vložit řádek <file>const GObject = imports.gi.GObject;</file> na začátek kódu aplikace tak, jako jsem učinili v tomto příkladu.

note: (itstool) path: section/code
en: 
            // This array holds our list of options and their icons
            let options = [{ name: "Select" },
                { name: "New", icon: Gtk.STOCK_NEW },
                { name: "Open", icon: Gtk.STOCK_OPEN },
                { name: "Save", icon: Gtk.STOCK_SAVE }];
    
            // Put the options in the liststore
            for (let i = 0; i &lt; options.length; i++ ) {
                let option = options[i];
                let iter = this._listStore.append();
                this._listStore.set (iter, [0], [option.name]);
                if ('icon' in option)
                    this._listStore.set (iter, [1], [option.icon]);
            }
cs: 
            // Toto pole uchovává seznam voleb a jejich ikony
            let options = [{ name: "Select" },
                { name: "New", icon: Gtk.STOCK_NEW },
                { name: "Open", icon: Gtk.STOCK_OPEN },
                { name: "Save", icon: Gtk.STOCK_SAVE }];
    
            // Vložení voleb do ListStore
            for (let i = 0; i &lt; options.length; i++ ) {
                let option = options[i];
                let iter = this._listStore.append();
                this._listStore.set (iter, [0], [option.name]);
                if ('icon' in option)
                    this._listStore.set (iter, [1], [option.icon]);
            }

note: (itstool) path: section/p
en: Here we create an array of the text options and their corresponding icons, then put them into the ListStore in much the same way we would for a <link xref="treeview_simple_liststore.js">TreeView's</link> ListStore. We only want to put an icon in if there's actually an icon in the options array, so we make sure to check for that first.
cs: Zde vytváříme pole s textovými volbami a jim odpovídajícími ikonami a pak je vložíme do <code>ListStore</code> více méně stejným způsobem, jako jsem použili pro <code>ListStore</code> v ukázce <link xref="treeview_simple_liststore.js">TreeView</link>. Ikonu chceme vložit jen v případě, že v položce pole opravdu nějaká je, takže to nejprve zkontrolujeme.

note: (itstool) path: note/p
en: "Select" isn't really an option so much as an invitation to click on our ComboBox, so it doesn't need an icon.
cs: Položka „Select“ není skutečná volba, ale jen takové pozvání ke kliknutí na náš rozbalovací seznam, a proto nemá ikonu.

note: (itstool) path: section/title
en: Creating the ComboBox
cs: Vytvoření ComboBox

note: (itstool) path: section/code
en: 
            // Create the combobox
            this._comboBox = new Gtk.ComboBox({
                model: this._listStore});
cs: 
            // Vytvoří rozbalovací seznam
            this._comboBox = new Gtk.ComboBox({
                model: this._listStore});

note: (itstool) path: section/p
en: Each ComboBox has an underlying "model" it takes all its options from. You can use a TreeStore if you want to have a ComboBox with branching options. In this case, we're just using the ListStore we already created.
cs: Každý rozbalovací seznam má podkladový „model“ obsahující všechny jeho volby. Pokud máte rozbalovací seznam s rozvětvenými volbami, můžete použít <code>TreeStore</code> (stromové úložiště). V tomto případě používáme již vytvořený <code>ListStore</code> (seznamové úložiště).

note: (itstool) path: section/code
en: 
            // Create some cellrenderers for the items in each column
            let rendererPixbuf = new Gtk.CellRendererPixbuf();
            let rendererText = new Gtk.CellRendererText();
    
            // Pack the renderers into the combobox in the order we want to see
            this._comboBox.pack_start (rendererPixbuf, false);
            this._comboBox.pack_start (rendererText, false);
    
            // Set the renderers to use the information from our liststore
            this._comboBox.add_attribute (rendererText, "text", 0);
            this._comboBox.add_attribute (rendererPixbuf, "stock_id", 1);
cs: 
            // Vytvoří vykreslovač buněk pro položky v jednotlivých sloupcích
            let rendererPixbuf = new Gtk.CellRendererPixbuf();
            let rendererText = new Gtk.CellRendererText();
    
            // Zabalí vykreslovač buněk do rozbalovacího seznamu v pořadí, v jakém je chcem vidět
            this._comboBox.pack_start (rendererPixbuf, false);
            this._comboBox.pack_start (rendererText, false);
    
            // Nataví vykreslovač buněk, aby se používaly informace z našeho ListStore
            this._comboBox.add_attribute (rendererText, "text", 0);
            this._comboBox.add_attribute (rendererPixbuf, "stock_id", 1);

note: (itstool) path: section/p
en: This part, again, works much like creating CellRenderers and packing them into the columns of a <link xref="treeview_simple_liststore.js">TreeView</link>. The biggest difference is that we don't need to create the ComboBox's columns as separate objects. We just pack the CellRenderers into it in the order we want them to show up, then tell them to pull information from the ListStore (and what type of information we want them to expect).
cs: Tato část opět pracuje podobně, jako u vytváření vykreslovačů buněk a balení položek do sloupců u příkladu s <link xref="treeview_simple_liststore.js">TreeView</link>. Největší rozdíl je, že nepotřebujeme vytvářet sloupce rozbalovacího seznamu jako oddělené objekty. Jednoduše zabalíme vykreslovače buněk do <code>ComboBox</code> v pořadí, v jakém chceme objekty zobrazovat, a řekneme jim, že mají informace získávat z <code>ListStore</code> (a typ dat, která očekáváme).

note: (itstool) path: section/p
en: We use a CellRendererText to show the text, and a CellRendererPixbuf to show the icons. We can store the names of the icons' stock types as strings, but when we display them we need a CellRenderer that's designed for pictures.
cs: Používáme <code>CellRendererText</code> pro zobrazení textu a <code>CellRendererPixbuf</code> pro zobrazení ikon. Názvy standardních ikon můžeme uchovávat v podobě řetězců, ale když je potřeba, zobrazíme je pomocí příslušného vykreslovače jako obrázky.

note: (itstool) path: note/p
en: Just like with a TreeView, the "model" (in this case a ListStore) and the "view" (in this case our ComboBox) are separate. Because of that, we can do things like have the columns in one order in the ListStore, and then pack the CellRenderers that correspond to those columns into the ComboBox in a different order. We can even create a TreeView or other widget that shows the information in the ListStore in a different way, without it affecting our ComboBox.
cs: Obdobně, jako u <code>TreeView</code>, jsou „model“ (v tomto případě <code>ListStore</code>) a „zobrazení“ (v tomto případě <code>ComboBox</code>) oddělené. Díky tomu můžeme dělat věci, jako je mít sloupce v nějakém pořadí v <code>ListStore</code> a vykreslovače buněk pak zabalit tak, že budou tyto sloupce odpovídat jinému pořadí v <code>ComboBox</code>. Můžeme vytvořit <code>TreeView</code> nebo jiný widget, který zobrazuje informace z <code>ListStore</code> v jiném pořadí, aniž by to ovlivnilo náš rozbalovací seznam.

note: (itstool) path: section/code
en: 
            // Set the first row in the combobox to be active on startup
            this._comboBox.set_active (0);
    
            // Connect the combobox's 'changed' signal to our callback function
            this._comboBox.connect ('changed', this._onComboChanged.bind(this));
cs: 
            // Nastavení prvního řádku v rozbalovacím seznamu, aby byl aktivní po spuštění
            this._comboBox.set_active (0);
    
            // Napojení signálu „changed“ od rozbalovacího seznamu na naši funkci zpětného volání
            this._comboBox.connect ('changed', this._onComboChanged.bind(this));

note: (itstool) path: section/p
en: We want the "Select" text to be the part people see at first, that gets them to click on the ComboBox. So we set it to be the active entry. We also connect the ComboBox's <file>changed</file> signal to a callback function, so that any time someone clicks on a new option something happens. In this case, we're just going to show a popup with a little haiku.
cs: Chceme, aby součástí byl text „Select“, který lidé uvidí jako první, aby je vyzval ke kliknutí na rozbalovací seznam. Takže jej nastavíme, aby byl aktivní položkou. Dále pak napojíme signál <code>"changed"</code> rozbalovacího seznamu na funkci zpětného volání, takže kdykoliv někdo klikne na novou volbu, něco se stane. V tomto případě jen zobrazíme dialogové okno s drobnou haiku.

note: (itstool) path: section/code
en: 
            // Add the combobox to the window
            this._window.add (this._comboBox);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
cs: 
            // Přidá rozbalovací seznam do okna
            this._window.add (this._comboBox);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }

note: (itstool) path: section/p
en: Finally, we add the ComboBox to the window, and tell the window to show itself and everything inside it.
cs: Nakonec přidáme <code>ComboBox</code> do okna a oknu řekneme ať zobrazí sebe a vše co obsahuje.

note: (itstool) path: section/code
en: 
        _selected() {
    
            // The silly pseudohaiku that we'll use for our messagedialog
            let haiku = ["",
                "You ask for the new\nwith no thought for the aged\nlike fallen leaves trod.",
                "Like a simple clam\nrevealing a lustrous pearl\nit opens for you.",
                "A moment in time\na memory on the breeze\nthese things can't be saved."];
cs: 
        _selected() {
    
            // Bláznivá pseudohaiku, kterou použijeme do dialogového okna se zprávou
            let haiku = ["",
                "You ask for the new\nwith no thought for the aged\nlike fallen leaves trod.",
                "Like a simple clam\nrevealing a lustrous pearl\nit opens for you.",
                "A moment in time\na memory on the breeze\nthese things can't be saved."];

note: (itstool) path: section/p
en: We're going to create a pop-up <link xref="messagedialog.js">MessageDialog</link>, which shows you a silly haiku based on which distro you select. First, we create the array of haiku to use. Since the first string in our ComboBox is just the "Select" message, we make the first string in our array blank.
cs: Nyní pojďme vytvořit vyskakovací <link xref="messagedialog.js">MessageDialog</link>, který vám zobrazí bláznivou haiku odpovídající tomu, kterou distribuci vyberete. Nejprve vytvoříme pole použitých haiku. Protože první řetězec v našem rozbalovacím seznamu je jen zpráva „Select“, ponecháme první řetězec v poli prázdný.

note: (itstool) path: section/code
en: 
            // Which combobox item is active?
            let activeItem = this._comboBox.get_active();
    
            // No messagedialog if you choose "Select"
            if (activeItem != 0) {
                this._popUp = new Gtk.MessageDialog ({
                    transient_for: this._window,
                    modal: true,
                    buttons: Gtk.ButtonsType.OK,
                    message_type: Gtk.MessageType.INFO,
                    text: haiku[activeItem]});
    
                // Connect the OK button to a handler function
                this._popUp.connect ('response', this._onDialogResponse.bind(this));
    
                // Show the messagedialog
                this._popUp.show();
            }
    
        }
cs: 
            // Která položka v rozbalovacím seznamu je aktivní?
            let activeItem = this._comboBox.get_active();
    
            // Žádné dialogové okno se zprávou, když zvolíte „Select“
            if (activeItem != 0) {
                this._popUp = new Gtk.MessageDialog ({
                    transient_for: this._window,
                    modal: true,
                    buttons: Gtk.ButtonsType.OK,
                    message_type: Gtk.MessageType.INFO,
                    text: haiku[activeItem]});
    
                // Napojí tlačítko OK na zpracující funkci
                this._popUp.connect ('response', this._onDialogResponse.bind(this));
    
                // Zobrazí dialogové okno se zprávou
                this._popUp.show();
            }
    
        }

note: (itstool) path: section/p
en: Before showing a MessageDialog, we first test to make sure you didn't choose the "Select" message. After that, we set its text to be the haiku in the array that corresponds to the active entry in our ComboBoxText. We do that using the <file>get_active</file> method, which returns the number ID of your selection.
cs: Než dialogové okno se zprávou zobrazíme, provedeme test, abychom se ujistili, než není vybrána zpráva „Select“. Pak pro něj nastavíme text haiku z pole, který bude odpovídat aktivní položce v našem rozbalovacím seznamu. To uděláme pomocí metody <code>get_active</code>, která vrací číselné ID výběru.

note: (itstool) path: note/p
en: Other methods you can use include <file>get_active_id</file>, which returns the text ID assigned by <file>append</file>, and <file>get_active_text</file>, which returns the full text of the string you selected.
cs: Jinými metodami, které bychom mohli použít jsou <code>get_active_id</code>, která vrací textové ID přiřazené metodou <code>append</code>, a <code>get_active_text</code>, která vrací celý text ve vybrané položce.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new ComboBoxExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new ComboBoxExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished ComboBoxExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci konečné třídy ComboBoxExample a aplikaci spustíme.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const GObject = imports.gi.GObject;
    const Gtk = imports.gi.Gtk;
    
    class ComboBoxExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jscombobox'});
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present ();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_width: 200,
                border_width: 10 });
    
            // Create the liststore to put our options in
            this._listStore = new Gtk.ListStore();
            this._listStore.set_column_types ([
                GObject.TYPE_STRING,
                GObject.TYPE_STRING]);
    
            // This array holds our list of options and their icons
            let options = [{ name: "Select" },
                { name: "New", icon: Gtk.STOCK_NEW },
                { name: "Open", icon: Gtk.STOCK_OPEN },
                { name: "Save", icon: Gtk.STOCK_SAVE }];
    
            // Put the options in the liststore
            for (let i = 0; i &lt; options.length; i++ ) {
                let option = options[i];
                let iter = this._listStore.append();
                this._listStore.set (iter, [0], [option.name]);
                if ('icon' in option)
                    this._listStore.set (iter, [1], [option.icon]);
            }
    
            // Create the combobox
            this._comboBox = new Gtk.ComboBox({
                model: this._listStore});
    
            // Create some cellrenderers for the items in each column
            let rendererPixbuf = new Gtk.CellRendererPixbuf();
            let rendererText = new Gtk.CellRendererText();
    
            // Pack the renderers into the combobox in the order we want to see
            this._comboBox.pack_start (rendererPixbuf, false);
            this._comboBox.pack_start (rendererText, false);
    
            // Set the renderers to use the information from our liststore
            this._comboBox.add_attribute (rendererText, "text", 0);
            this._comboBox.add_attribute (rendererPixbuf, "stock_id", 1);
    
            // Set the first row in the combobox to be active on startup
            this._comboBox.set_active (0);
    
            // Connect the combobox's 'changed' signal to our callback function
            this._comboBox.connect ('changed', this._onComboChanged.bind(this));
    
            // Add the combobox to the window
            this._window.add (this._comboBox);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _onComboChanged() {
    
            // The silly pseudohaiku that we'll use for our messagedialog
            let haiku = ["",
                "You ask for the new\nwith no thought for the aged\nlike fallen leaves trod.",
                "Like a simple clam\nrevealing a lustrous pearl\nit opens for you.",
                "A moment in time\na memory on the breeze\nthese things can't be saved."];
    
            // Which combobox item is active?
            let activeItem = this._comboBox.get_active();
    
            // No messagedialog if you choose "Select"
            if (activeItem != 0) {
                this._popUp = new Gtk.MessageDialog ({
                    transient_for: this._window,
                    modal: true,
                    buttons: Gtk.ButtonsType.OK,
                    message_type: Gtk.MessageType.INFO,
                    text: haiku[activeItem]});
    
                // Connect the OK button to a handler function
                this._popUp.connect ('response', this._onDialogResponse.bind(this));
    
                // Show the messagedialog
                this._popUp.show();
            }
    
        }
    
        _onDialogResponse() {
    
            this._popUp.destroy ();
    
        }
    
    };
    
    // Run the application
    let app = new ComboBoxExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const GObject = imports.gi.GObject;
    const Gtk = imports.gi.Gtk;
    
    class ComboBoxExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jscombobox'});
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate", která zobrazí okno při aktivaci
        _onActivate() {
            this._window.present ();
        }
    
        // Funkce zpětného volání pro signál "startup", která sestaví uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_width: 200,
                border_width: 10 });
    
            // Vytvoří ListStore pro vložení našich voleb
            this._listStore = new Gtk.ListStore();
            this._listStore.set_column_types ([
                GObject.TYPE_STRING,
                GObject.TYPE_STRING]);
    
            // Toto pole uchovává seznam voleb a jejich ikony
            let options = [{ name: "Select" },
                { name: "New", icon: Gtk.STOCK_NEW },
                { name: "Open", icon: Gtk.STOCK_OPEN },
                { name: "Save", icon: Gtk.STOCK_SAVE }];
    
            // Vloží volby do ListStore
            for (let i = 0; i &lt; options.length; i++ ) {
                let option = options[i];
                let iter = this._listStore.append();
                this._listStore.set (iter, [0], [option.name]);
                if ('icon' in option)
                    this._listStore.set (iter, [1], [option.icon]);
            }
    
            // Vytvoří rozbalovací seznam
            this._comboBox = new Gtk.ComboBox({
                model: this._listStore});
    
            // Vytvoří vykreslovače buněk pro položky v jednotlivých sloupcích
            let rendererPixbuf = new Gtk.CellRendererPixbuf();
            let rendererText = new Gtk.CellRendererText();
    
            // Zabalí vykreslovače buněk do rozbalovacího seznamu v pořadí, v jakém je chcem vidět
            this._comboBox.pack_start (rendererPixbuf, false);
            this._comboBox.pack_start (rendererText, false);
    
            // Nataví vykreslovače buněk, aby používaly informace z našeho ListStore
            this._comboBox.add_attribute (rendererText, "text", 0);
            this._comboBox.add_attribute (rendererPixbuf, "stock_id", 1);
    
            // Nastaví první řádek v rozbalovacím seznamu, aby byl aktivní po spuštění
            this._comboBox.set_active (0);
    
            // Napojí signály „changed“ od rozbalovacího seznamu na naši funkci zpětného volání
            this._comboBox.connect ('changed', this._onComboChanged.bind(this));
    
            // Přidá rozbalovací seznam do okna
            this._window.add (this._comboBox);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _onComboChanged() {
    
            // Bláznivá pseudohaiku, kterou použijeme do dialogového okna se zprávou
            let haiku = ["",
                "You ask for the new\nwith no thought for the aged\nlike fallen leaves trod.",
                "Like a simple clam\nrevealing a lustrous pearl\nit opens for you.",
                "A moment in time\na memory on the breeze\nthese things can't be saved."];
    
            // Která položka v rozbalovacím seznamu je aktivní?
            let activeItem = this._comboBox.get_active();
    
            // Žádné dialogové okno se zprávou, když zvolíte „Select“
            if (activeItem != 0) {
                this._popUp = new Gtk.MessageDialog ({
                    transient_for: this._window,
                    modal: true,
                    buttons: Gtk.ButtonsType.OK,
                    message_type: Gtk.MessageType.INFO,
                    text: haiku[activeItem]});
    
                // Napojí tlačítko OK na zpracující funkci
                this._popUp.connect ('response', this._onDialogResponse.bind(this));
    
                // Zobrazí dialogové okno se zprávou
                this._popUp.show();
            }
    
        }
    
        _onDialogResponse() {
    
            this._popUp.destroy ();
    
        }
    
    };
    
    // Spustí aplikaci
    let app = new ComboBoxExample ();
    app.application.run (ARGV);

note: (itstool) path: page/title
en: ComboBox (one column)
cs: ComboBox (jeden sloupec)

note: (itstool) path: page/p
en: This ComboBox prints to the terminal your selection when you change it.
cs: Tento rozbalovací seznam vypíše do terminálu, co jste si vybrali, když provedete změnu.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    distros = [["Select distribution"], ["Fedora"], ["Mint"], ["Suse"]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(200, -1)
            self.set_border_width(10)
    
            # the data in the model, of type string
            listmodel = Gtk.ListStore(str)
            # append the data in the model
            for i in range(len(distros)):
                listmodel.append(distros[i])
    
            # a combobox to see the data stored in the model
            combobox = Gtk.ComboBox(model=listmodel)
    
            # a cellrenderer to render the text
            cell = Gtk.CellRendererText()
    
            # pack the cell into the beginning of the combobox, allocating
            # no more space than needed
            combobox.pack_start(cell, False)
            # associate a property ("text") of the cellrenderer (cell) to a column (column 0)
            # in the model used by the combobox
            combobox.add_attribute(cell, "text", 0)
    
            # the first row is the active one by default at the beginning
            combobox.set_active(0)
    
            # connect the signal emitted when a row is selected to the callback
            # function
            combobox.connect("changed", self.on_changed)
    
            # add the combobox to the window
            self.add(combobox)
    
        def on_changed(self, combo):
            # if the row selected is not the first one, write its value on the
            # terminal
            if combo.get_active() != 0:
                print("You chose " + str(distros[combo.get_active()][0]) + ".")
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    distros = [["Select distribution"], ["Fedora"], ["Mint"], ["Suse"]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(200, -1)
            self.set_border_width(10)
    
            # Data v modelu, typu string
            listmodel = Gtk.ListStore(str)
            # Naplní data do modelu
            for i in range(len(distros)):
                listmodel.append(distros[i])
    
            # Rozbalovací seznam pro zobrazení dat uložených v modelu
            combobox = Gtk.ComboBox(model=listmodel)
    
            # CellRenderer pro vykreslování textu
            cell = Gtk.CellRendererText()
    
            # Zabalí buňku do začátku rozbalovacího seznamu, nepřiděluje
            # více místa, než je zapotřebí
            combobox.pack_start(cell, False)
            # Přiřadí vlastnost ("text") vykreslovače buňky (cell) sloupci (column 0)
            # v modelu použitém rozbalovacím seznamem
            combobox.add_attribute(cell, "text", 0)
    
            # První řádek je ve výchozím stavu na začátku aktivní
            combobox.set_active(0)
    
            # Napojí signál vyslaný při vybrání řádku na funkci zpětného
            # volání
            combobox.connect("changed", self.on_changed)
    
            # Přidá rozbalovací seznam do okna
            self.add(combobox)
    
        def on_changed(self, combo):
            # Pokud vybraný řádek není prvním řádkem, vypíše se jeho hodnota
            # do terminálu
            if combo.get_active() != 0:
                print("You chose " + str(distros[combo.get_active()][0]) + ".")
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a ComboBox widget
cs: Užitečné metody pro widget ComboBox

note: (itstool) path: section/p
en: The ComboBox widget is designed around a <em>Model/View/Controller</em> design: the <em>Model</em> stores the data; the <em>View</em> gets change notifications and displays the content of the model; the <em>Controller</em>, finally, changes the state of the model and notifies the view of these changes. For more information and for a list of useful methods for ComboBox see <link xref="model-view-controller.py"/>.
cs: Widget <code>ComboBox</code> je vytvořen okolo návrhu <em>Model/Zobrazení/Ovládání</em>: <em>Model</em> uchovává data, <em>Zobrazení</em> dodává upozornění na změny a zobrazuje obsah modelu a konečně <em>Ovládání</em> mění stav modelu a upozorňuje zobrazení na tyto změny. Více informací a seznam použitelných metod pro <code>ComboBox</code> najdete v <link xref="model-view-controller.py"/>.

note: (itstool) path: section/p
en: In line 35 the <code>"changed"</code> signal is connected to the callback function <code>on_changed()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 35 je signál <code>"changed"</code> napojen na funkci zpětného volání <code>on_changed()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: <link href="https://gitlab.gnome.org/GNOME/pygobject/blob/master/gi/overrides/Gtk.py">pygobject - Python bindings for GObject Introspection</link>
cs: <link href="https://gitlab.gnome.org/GNOME/pygobject/blob/master/gi/overrides/Gtk.py">pygobject – vazba jazyka Python pro GObject Introspection</link>

note: (itstool) path: page/code
en: /* A window in the application */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* An instance array of linux distributions belonging to this window. */
    	string[] distros = {"Select distribution", "Fedora", "Mint", "Suse"};
    
    	/* This enum makes the code more readable when we refer to
    	 * the column as Column.DISTRO, instead of just 0.
    	 */
    	enum Column {
    		DISTRO
    	}
    
    	/* Constructor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Welcome to GNOME");
    
    		this.set_default_size (200, -1);
    		this.border_width = 10;
    
    		Gtk.ListStore liststore = new Gtk.ListStore (1, typeof (string));
    
    		for (int i = 0; i &lt; distros.length; i++){
    			Gtk.TreeIter iter;
    			liststore.append (out iter);
    			liststore.set (iter, Column.DISTRO, distros[i]);
    		}
    
    		Gtk.ComboBox combobox = new Gtk.ComboBox.with_model (liststore);
    		Gtk.CellRendererText cell = new Gtk.CellRendererText ();
    		combobox.pack_start (cell, false);
    
    		combobox.set_attributes (cell, "text", Column.DISTRO);
    
    		/* Set the first item in the list to be selected (active). */
    		combobox.set_active (0);
    
    		/* Connect the 'changed' signal of the combobox
    		 * to the signal handler (aka. callback function).
    		 */
    		combobox.changed.connect (this.item_changed);
    
    		/* Add the combobox to this window */
    		this.add (combobox);
    		combobox.show ();
    	}
    
    	/* Signal handler for the 'changed' signal of the combobox. */
    	void item_changed (Gtk.ComboBox combo) {
    		if (combo.get_active () !=0) {
    			print ("You chose " + distros [combo.get_active ()] +"\n");
    		}
    	}
    }
    
    /* This is the application */
    class MyApplication : Gtk.Application {
    
    	/* Constructor */
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    
    	/* Override the activate signal of GLib.Application,
    	 * which is inherited by Gtk.Application.
    	 */
    	protected override void activate () {
    
    		/* Create the window of this application
    		 * and show it.
    		 */
    		new MyWindow (this).show ();
    	}
    }
    
    /* main creates and runs the application */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Okno v aplikaci */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* Instance pole s linuxovými distribucemi náležející do tohoto okna */
    	string[] distros = {"Select distribution", "Fedora", "Mint", "Suse"};
    
    	/* Tento výčet dělá kód lépe čitelným, když se odkazujeme na sloupec
    	 * jako Column.DISTRO namísto 0.
    	 */
    	enum Column {
    		DISTRO
    	}
    
    	/* Konstruktor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Welcome to GNOME");
    
    		this.set_default_size (200, -1);
    		this.border_width = 10;
    
    		Gtk.ListStore liststore = new Gtk.ListStore (1, typeof (string));
    
    		for (int i = 0; i &lt; distros.length; i++){
    			Gtk.TreeIter iter;
    			liststore.append (out iter);
    			liststore.set (iter, Column.DISTRO, distros[i]);
    		}
    
    		Gtk.ComboBox combobox = new Gtk.ComboBox.with_model (liststore);
    		Gtk.CellRendererText cell = new Gtk.CellRendererText ();
    		combobox.pack_start (cell, false);
    
    		combobox.set_attributes (cell, "text", Column.DISTRO);
    
    		/* Nastaví první položku v seznamu jako vybranou (aktivní) */
    		combobox.set_active (0);
    
    		/* Napojí signál "changed" rozbalovacího seznamu
    		 * na obsluhu signálu (neboli funkci zpětného volání)
    		 */
    		combobox.changed.connect (this.item_changed);
    
    		/* Přidá rozbalovací seznam do tohoto okna */
    		this.add (combobox);
    		combobox.show ();
    	}
    
    	/* Zpracování signálu pro signál "changed" rozbalovacího seznamu */
    	void item_changed (Gtk.ComboBox combo) {
    		if (combo.get_active () !=0) {
    			print ("You chose " + distros [combo.get_active ()] +"\n");
    		}
    	}
    }
    
    /* Toto je aplikace */
    class MyApplication : Gtk.Application {
    
    	/* Konstruktor */
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    
    	/* Přepíše signál "activate" z GLib.Application,
    	 * který je zděděný z Gtk.Application
    	 */
    	protected override void activate () {
    
    		/* Vytvoří okno této aplikace a zobrazí jej */
    		new MyWindow (this).show ();
    	}
    }
    
    /* main vytvoří a spustí aplikaci */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: page/title
en: ComboBox (two columns)
cs: ComboBox (dva sloupce)

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    actions = [["Select", None],
               ["New", Gtk.STOCK_NEW],
               ["Open", Gtk.STOCK_OPEN],
               ["Save", Gtk.STOCK_SAVE]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(200, -1)
            self.set_border_width(10)
    
            # the data in the model, of type string on two columns
            listmodel = Gtk.ListStore(str, str)
            # append the data
            for i in range(len(actions)):
                listmodel.append(actions[i])
    
            # a combobox to see the data stored in the model
            combobox = Gtk.ComboBox(model=listmodel)
    
            # cellrenderers to render the data
            renderer_pixbuf = Gtk.CellRendererPixbuf()
            renderer_text = Gtk.CellRendererText()
    
            # we pack the cell into the beginning of the combobox, allocating
            # no more space than needed;
            # first the image, then the text;
            # note that it does not matter in which order they are in the model,
            # the visualization is decided by the order of the cellrenderers
            combobox.pack_start(renderer_pixbuf, False)
            combobox.pack_start(renderer_text, False)
    
            # associate a property of the cellrenderer to a column in the model
            # used by the combobox
            combobox.add_attribute(renderer_text, "text", 0)
            combobox.add_attribute(renderer_pixbuf, "stock_id", 1)
    
            # the first row is the active one at the beginning
            combobox.set_active(0)
    
            # connect the signal emitted when a row is selected to the callback
            # function
            combobox.connect("changed", self.on_changed)
    
            # add the combobox to the window
            self.add(combobox)
    
        def on_changed(self, combo):
            # if the row selected is not the first one, write on the terminal
            # the value of the first column in the model
            if combo.get_active() != 0:
                print("You chose " + str(actions[combo.get_active()][0]) + "\n")
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    actions = [["Select", None],
               ["New", Gtk.STOCK_NEW],
               ["Open", Gtk.STOCK_OPEN],
               ["Save", Gtk.STOCK_SAVE]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(200, -1)
            self.set_border_width(10)
    
            # Data v modelu, typu string ve dvou sloupcích
            listmodel = Gtk.ListStore(str, str)
            # Naplní data do modelu
            for i in range(len(actions)):
                listmodel.append(actions[i])
    
            # Rozbalovací seznam pro zobrazení dat uložených v modelu
            combobox = Gtk.ComboBox(model=listmodel)
    
            # CellRenderer pro vykreslování dat
            renderer_pixbuf = Gtk.CellRendererPixbuf()
            renderer_text = Gtk.CellRendererText()
    
            # Zabalí buňku do začátku rozbalovacího seznamu, nepřiděluje
            # více místa, než je zapotřebí
            # První je obrázek, potom text
            # Uvědomte si, že nezáleží na pořadí, ve jakém jsou v modelu,
            # vizualizace je dána pořadím vykreslovačů buněk
            combobox.pack_start(renderer_pixbuf, False)
            combobox.pack_start(renderer_text, False)
    
            # Přiřadí vlastnost vykreslovače buňky sloupci v modelu
            # použitém rozbalovacím seznamem
            combobox.add_attribute(renderer_text, "text", 0)
            combobox.add_attribute(renderer_pixbuf, "stock_id", 1)
    
            # První řádek je ve výchozím stavu na začátku aktivní
            combobox.set_active(0)
    
            # Napojí signál vyslaný při vybrání řádku na funkci zpětného
            # volání
            combobox.connect("changed", self.on_changed)
    
            # Přidá rozbalovací seznam do okna
            self.add(combobox)
    
        def on_changed(self, combo):
            # Pokud vybraný řádek není prvním řádkem, vypíše se hodnota prvního
            # sloupce v modelu
            if combo.get_active() != 0:
                print("You chose " + str(actions[combo.get_active()][0]) + "\n")
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/p
en: In line 45 the <code>"changed"</code> signal is connected to the callback function <code>on_changed()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 45 je signál <code>"changed"</code> napojen na funkci zpětného volání <code>on_changed()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/gtk3/unstable/gtk3-Stock-Items.html">Stock Items</link>
cs: <link href="http://developer.gnome.org/gtk3/unstable/gtk3-Stock-Items.html">Standardní položky</link>

note: (itstool) path: section/code
en: class MyWindow : Gtk.ApplicationWindow {
    
    	string[] file = {"Select", "New", "Open", "Save"};
    	string[] stock_item = {"","gtk-new", "gtk-open", "gtk-save"};
    
    	enum Column {
    		FILE,
    		STOCK_ITEM	
    	}
    
    	/* Constructor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Welcome to GNOME");
    
    		this.set_default_size (200, -1);
    		this.border_width = 10;
    
    		Gtk.ListStore liststore = new Gtk.ListStore (2, typeof (string), typeof (string));
    
    		for (int i = 0; i &lt; file.length; i++){
    			Gtk.TreeIter iter;
    			liststore.append (out iter);
    			liststore.set (iter, Column.FILE, file[i]);
    			liststore.set (iter, Column.STOCK_ITEM, stock_item[i]);
    		}
    
    		Gtk.ComboBox combobox = new Gtk.ComboBox.with_model (liststore);
    
    		/* CellRenderers render the data. */
    		Gtk.CellRendererText cell = new Gtk.CellRendererText ();
    		Gtk.CellRendererPixbuf cell_pb = new Gtk.CellRendererPixbuf ();
    		
                    /* we pack the cell into the beginning of the combobox, allocating
    		 * no more space than needed;
    		 * first the image, then the text;
    		 * note that it does not matter in which order they are in the model,
    		 * the visualization is decided by the order of the cellrenderers
    		 */
    		combobox.pack_start (cell_pb, false);
    		combobox.pack_start (cell, false);
    
    		/* associate a property of the cellrenderer to a column in the model
    		 * used by the combobox
    		 */
    		combobox.set_attributes (cell_pb, "stock_id", Column.STOCK_ITEM);
    		combobox.set_attributes (cell, "text", Column.FILE);
    
    		/* Set the first item in the list to be selected (active). */
    		combobox.set_active (0);
    
    		/* Connect the 'changed' signal of the combobox
    		 * to the signal handler (aka. callback function).
    		 */
    		combobox.changed.connect (this.item_changed);
    
    		/* Add the combobox to this window */
    		this.add (combobox);
    		combobox.show ();
    	}
    
    	void item_changed (Gtk.ComboBox combo) {
    		if (combo.get_active () !=0) {
    			print ("You chose " + file [combo.get_active ()] +"\n");
    		}
    	}
    }
    
    class MyApplication : Gtk.Application {
            protected override void activate () {
                    new MyWindow (this).show ();
            }
    }
    
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: class MyWindow : Gtk.ApplicationWindow {
    
    	string[] file = {"Select", "New", "Open", "Save"};
    	string[] stock_item = {"","gtk-new", "gtk-open", "gtk-save"};
    
    	enum Column {
    		FILE,
    		STOCK_ITEM	
    	}
    
    	/* Konstruktor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Welcome to GNOME");
    
    		this.set_default_size (200, -1);
    		this.border_width = 10;
    
    		Gtk.ListStore liststore = new Gtk.ListStore (2, typeof (string), typeof (string));
    
    		for (int i = 0; i &lt; file.length; i++){
    			Gtk.TreeIter iter;
    			liststore.append (out iter);
    			liststore.set (iter, Column.FILE, file[i]);
    			liststore.set (iter, Column.STOCK_ITEM, stock_item[i]);
    		}
    
    		Gtk.ComboBox combobox = new Gtk.ComboBox.with_model (liststore);
    
    		/* CellRenderers vykreslující data */
    		Gtk.CellRendererText cell = new Gtk.CellRendererText ();
    		Gtk.CellRendererPixbuf cell_pb = new Gtk.CellRendererPixbuf ();
    		
                    /* Zabalí buňku do začátku rozbalovacího seznamu, nepřiděluje více
    		 * místa, než je zapotřebí.
    		 * První je obrázek, potom text.
    		 * Uvědomte si, že nezáleží na pořadí, ve jakém jsou v modelu,
    		 * vizualizace je dána pořadím vykreslovačů buněk
    		 */
    		combobox.pack_start (cell_pb, false);
    		combobox.pack_start (cell, false);
    
    		/* Přiřadí vlastnost cellrenderer sloupci v modelu použítém
    		 * rozbalovacím seznamem
    		 */
    		combobox.set_attributes (cell_pb, "stock_id", Column.STOCK_ITEM);
    		combobox.set_attributes (cell, "text", Column.FILE);
    
    		/* Nastaví první položku v seznamu jako vybranou (aktivní) */
    		combobox.set_active (0);
    
    		/* Napojí signál "changed" rozbalovacího seznamu na 
    		 * obsluhu signálu (neboli funkci zpětného volání)
    		 */
    		combobox.changed.connect (this.item_changed);
    
    		/* Přidá rozbalovací seznam do tohoto okna */
    		this.add (combobox);
    		combobox.show ();
    	}
    
    	void item_changed (Gtk.ComboBox combo) {
    		if (combo.get_active () !=0) {
    			print ("You chose " + file [combo.get_active ()] +"\n");
    		}
    	}
    }
    
    class MyApplication : Gtk.Application {
            protected override void activate () {
                    new MyWindow (this).show ();
            }
    }
    
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: page/title
en: Code samples and platform demos in C++
cs: Ukázky kódu a demonstrace platformy v jazyce C++

note: (itstool) path: section/title
en: Examples of applications
cs: Příklady aplikací

note: (itstool) path: info/desc
en: A popup window
cs: Vyskakovací okno

note: (itstool) path: page/p
en: A dialog window that pops up when a button is pressed.
cs: Dialogové okno, které vyskočí, když je zmáčknuto tlačítko.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
     
    
    /*Callback function in which reacts to the "response" signal. Be sure to place 
    it before the function it is called in*/
    static void
    on_response (GtkDialog *dialog,
                 gint       response_id,
                 gpointer   user_data)
    {
      /*For demonstration purposes, this will show the int value 
      of the response type*/
      g_print ("response is %d\n", response_id);
      
      /*This will cause the dialog to be destroyed*/
      gtk_widget_destroy (GTK_WIDGET (dialog));
    }
    
    
    
    /*Callback function in which reacts to the "clicked" signal*/
    static void
    show_dialog (GtkButton *button,
                 gpointer   user_data)
    {
      GtkWindow *window = user_data;
      GtkWidget *dialog;
      GtkWidget *content_area;
      GtkWidget *label;
    
      gint response_id;
    
      /*Create the dialog window. Modal windows prevent interaction with other 
      windows in the same application*/
      dialog = gtk_dialog_new_with_buttons ("A Gtk+ Dialog", 
                                            window, 
                                            GTK_DIALOG_MODAL, 
                                            GTK_STOCK_OK, 
                                            GTK_RESPONSE_OK, 
                                            NULL);
    
      /*Create a label and attach it to the content area of the dialog*/
      content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
      label = gtk_label_new ("This demonstrates a dialog with a label");
      gtk_container_add (GTK_CONTAINER (content_area), label);
    
      /*The main purpose of this is to show dialog's child widget, label*/
      gtk_widget_show_all (dialog);
      
      /*Connecting the "response" signal from the user to the associated
      callback function*/
      g_signal_connect (GTK_DIALOG (dialog), 
                        "response", 
                        G_CALLBACK (on_response), 
                        NULL);
    
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *button;
     
      /*Create a window with a title and a default size*/
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "GNOME Button");
      gtk_window_set_default_size (GTK_WINDOW (window), 250, 50);
    
      /*Create a button with a label, and add it to the window*/
      button = gtk_button_new_with_label ("Click Me");
      gtk_container_add (GTK_CONTAINER (window), button);
     
      /*Connecting the clicked signal to the callback*/
      g_signal_connect (GTK_BUTTON (button), 
                        "clicked", 
                        G_CALLBACK (show_dialog), 
                        GTK_WINDOW (window));
     
      gtk_widget_show_all (window);
    }
     
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
     
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
     
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
     
    
    /* Funkce zpětného volání, která reaguje na signál "response". Je nutné ji
       umístit před funkci, která ji volá */
    static void
    on_response (GtkDialog *dialog,
                 gint       response_id,
                 gpointer   user_data)
    {
      /* Pro demonstrační účely. Zobrazí celočíselnou hodnotu typu odpovědi. */
      g_print ("response is %d\n", response_id);
      
      /* Způsobí zlikvidování dialogového okna */
      gtk_widget_destroy (GTK_WIDGET (dialog));
    }
    
    
    
    /* Funkce zpětného volání, která reaguje na signál "clicked" */
    static void
    show_dialog (GtkButton *button,
                 gpointer   user_data)
    {
      GtkWindow *window = user_data;
      GtkWidget *dialog;
      GtkWidget *content_area;
      GtkWidget *label;
    
      gint response_id;
    
      /* Vytvoří dialogové okno. Modální okno zabraňuje interakci s ostatními
         okno ve stejné aplikaci */
      dialog = gtk_dialog_new_with_buttons ("A Gtk+ Dialog", 
                                            window, 
                                            GTK_DIALOG_MODAL, 
                                            GTK_STOCK_OK, 
                                            GTK_RESPONSE_OK, 
                                            NULL);
    
      /* Vytvoří popisek a připojí jej do oblasti obsahu dialogového okna */
      content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
      label = gtk_label_new ("This demonstrates a dialog with a label");
      gtk_container_add (GTK_CONTAINER (content_area), label);
    
      /* Hlavním účelem tohoto je zobrazi synovský widget (popisek) dialogového okna */
      gtk_widget_show_all (dialog);
      
      /* Napojí signál "response" od uživatele k příslušné funkci zpětného volání */
      g_signal_connect (GTK_DIALOG (dialog), 
                        "response", 
                        G_CALLBACK (on_response), 
                        NULL);
    
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *button;
     
      /* Vytvoří okno s názvem, šířkou okraje a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "GNOME Button");
      gtk_window_set_default_size (GTK_WINDOW (window), 250, 50);
    
      /* Vytvoří tlačítko s popiskem a přidá jej do okna */
      button = gtk_button_new_with_label ("Click Me");
      gtk_container_add (GTK_CONTAINER (window), button);
     
      /* Napojí signál "clicked" na zpětné volání */
      g_signal_connect (GTK_BUTTON (button), 
                        "clicked", 
                        G_CALLBACK (show_dialog), 
                        GTK_WINDOW (window));
     
      gtk_widget_show_all (window);
    }
     
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
     
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
     
      return status;
    }

note: (itstool) path: page/p
en: A customizable popup window, which has a content area and an action area. This example dialog's content area contains a short message, and its action area contains a button which dismisses the dialog.
cs: Přizpůsobitelné vyskakovací okno, které má oblast s obsahem a oblast s akcemi. V tomto případě je v jeho oblasti s obsahem krátká zpráva a v oblasti s akcemi tlačítko, které jej skryje.

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class DialogExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jsdialog',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
                this._window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                             window_position: Gtk.WindowPosition.CENTER,
                                                             title: "Gtk.Dialog Example",
                                                             default_height: 50,
                                                             default_width: 250 });
    
            // Create a button
            this._button = new Gtk.Button ({label: "Click Me"});
            this._window.add (this._button);
    
            // Bind it to the function that creates the dialog
            this._button.connect ("clicked", this._createDialog.bind(this));
    
                    // Show the window and all child widgets
                    this._window.show_all();
        }
    
        _createDialog() {
    
            // Create the dialog
            this._dialog = new Gtk.Dialog ({ transient_for: this._window,
                             modal: true,
                             title: "A Gtk+ dialog" });
    
            // Create the dialog's content area, which contains a message
            this._contentArea = this._dialog.get_content_area();
            this._message = new Gtk.Label ({label: "This demonstrates a dialog with a label"});
            this._contentArea.add (this._message);
    
            // Create the dialog's action area, which contains a stock OK button
            this._actionArea = this._dialog.get_action_area();
            this._OKButton = Gtk.Button.new_from_stock (Gtk.STOCK_OK);
            this._actionArea.add (this._OKButton);
    
            // Connect the button to the function that handles what it does
            this._OKButton.connect ("clicked", this._OKHandler.bind(this));
    
            this._dialog.show_all();
        }
    
        _OKHandler(dialog, response_id) {
    
            // Destroy the dialog
            this._dialog.destroy();
        }
    
    };
    
    // Run the application
    let app = new DialogExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class DialogExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jsdialog',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
                this._window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                             window_position: Gtk.WindowPosition.CENTER,
                                                             title: "Gtk.Dialog Example",
                                                             default_height: 50,
                                                             default_width: 250 });
    
            // Vytvoří tlačítko
            this._button = new Gtk.Button ({label: "Click Me"});
            this._window.add (this._button);
    
            // Napojí jej na funkci, který vytvoří dialogové okno
            this._button.connect ("clicked", this._createDialog.bind(this));
    
                    // Zobrazí okno a všechny jeho synovské widgety
                    this._window.show_all();
        },
    
        _createDialog: function () {
    
            // Vytvoří dialogové okno
            this._dialog = new Gtk.Dialog ({ transient_for: this._window,
                             modal: true,
                             title: "A Gtk+ dialog" });
    
            // Vytvoří v dialogovém okně oblast s obsahem, ve které bude zpráva
            this._contentArea = this._dialog.get_content_area();
            this._message = new Gtk.Label ({label: "This demonstrates a dialog with a label"});
            this._contentArea.add (this._message);
    
            // Vytvoří v dialogovém okně oblast s akcemi, ve které bude standardní tlačíko OK
            this._actionArea = this._dialog.get_action_area();
            this._OKButton = Gtk.Button.new_from_stock (Gtk.STOCK_OK);
            this._actionArea.add (this._OKButton);
    
            // Napojí tlačítko na funkci, které se bude starat o to, co se má udělat does
            this._OKButton.connect ("clicked", this._OKHandler.bind(this));
    
            this._dialog.show_all();
        }
    
        _OKHandler(dialog, response_id) {
    
            // Zlikviduje dialogové okno
            this._dialog.destroy();
        }
    
    };
    
    // Spustí aplikaci
    let app = new DialogExample ();
    app.application.run (ARGV);

note: (itstool) path: page/p
en: A dialog with the response signal connected to a callback function.
cs: Dialogové okno reagující na signál napojený na funkci zpětného volání.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # construct a window (the parent window)
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="GNOME Button", application=app)
            self.set_default_size(250, 50)
    
            # a button on the parent window
            button = Gtk.Button("Click me")
            # connect the signal "clicked" of the button with the function
            # on_button_click()
            button.connect("clicked", self.on_button_click)
            # add the button to the window
            self.add(button)
    
        # callback function for the signal "clicked" of the button in the parent
        # window
        def on_button_click(self, widget):
            # create a Gtk.Dialog
            dialog = Gtk.Dialog()
            dialog.set_title("A Gtk+ Dialog")
            # The window defined in the constructor (self) is the parent of the dialog.
            # Furthermore, the dialog is on top of the parent window
            dialog.set_transient_for(self)
            # set modal true: no interaction with other windows of the application
            dialog.set_modal(True)
            # add a button to the dialog window
            dialog.add_button(button_text="OK", response_id=Gtk.ResponseType.OK)
            # connect the "response" signal (the button has been clicked) to the
            # function on_response()
            dialog.connect("response", self.on_response)
    
            # get the content area of the dialog, add a label to it
            content_area = dialog.get_content_area()
            label = Gtk.Label("This demonstrates a dialog with a label")
            content_area.add(label)
            # show the dialog
            dialog.show_all()
    
        def on_response(self, widget, response_id):
            print("response_id is", response_id)
            # destroy the widget (the dialog) when the function on_response() is called
            # (that is, when the button of the dialog has been clicked)
            widget.destroy()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # Sestaví okno (rodičovské okno)
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="GNOME Button", application=app)
            self.set_default_size(250, 50)
    
            # Tlačítko v rodičovském okně
            button = Gtk.Button("Click me")
            # Napojí signál "clicked" tlačítka na funkci on_button_click()
            button.connect("clicked", self.on_button_click)
            # Přidá tlačítko do okna
            self.add(button)
    
        # Funkce zpětného volání pro signál "clicked" tlačítka v rodičovském
        # okně
        def on_button_click(self, widget):
            # Vytvoří Gtk.Dialog
            dialog = Gtk.Dialog()
            dialog.set_title("A Gtk+ Dialog")
            # Okno definované v konstruktoru (self) je rodičem dialogového okna
            # Navíc, dialogové okno je nad rodičovským oknem
            dialog.set_transient_for(self)
            # Nastaví modal true: nelze pracovat s ostaními okny této aplikace
            dialog.set_modal(True)
            # Přidá tlačítko do dialogového okna
            dialog.add_button(button_text="OK", response_id=Gtk.ResponseType.OK)
            # Napojí signál "response" (bylo kliknuto na tlačítko) na funkci
            # on_response()
            dialog.connect("response", self.on_response)
    
            # Získá oblast s obsahem dialogového okna, přidá do ní popisek
            content_area = dialog.get_content_area()
            label = Gtk.Label("This demonstrates a dialog with a label")
            content_area.add(label)
            # Zobrazí dialogové okno
            dialog.show_all()
    
        def on_response(self, widget, response_id):
            print("response_id is", response_id)
            # Zlikviduje widget (dialogové okno), když je zavolána funkce on_response()
            # (což je, když bylo kliknuto na tlačítko v dialogovém okně)
            widget.destroy()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Dialog widget
cs: Užitečné metody pro widget Dialog

note: (itstool) path: section/p
en: In line 16 the signal <code>"clicked"</code> is connected to the callback function <code>on_button_click()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 16 je signál <code>"clicked"</code> napojen na funkci zpětného volání <code>on_button_click()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: Instead of <code>set_modal(True)</code> we could have <code>set_modal(False)</code> followed by <code>set_destroy_with_parent(True)</code> that would destroy the dialog window if the main window is closed.
cs: Místo <code>set_modal(True)</code> bychom mohli mít <code>set_modal(False)</code> následované <code>set_destroy_with_parent(True)</code>, což by zlikvidovalo dialogové okno, když by se zavřelo hlavní okno.

note: (itstool) path: item/p
en: <code>add_button(button_text="The Answer", response_id=42)</code>, where <code>42</code> is any integer, is an alternative to <code>add_button(button_text="text", response_id=Gtk.ResponseType.RESPONSE)</code>, where <code>RESPONSE</code> could be one of <code>OK, CANCEL, CLOSE, YES, NO, APPLY, HELP</code>, which in turn correspond to the integers <code>-5, -6,..., -11</code>.
cs: <code>add_button(button_text="The Answer", response_id=42)</code>, kde <code>42</code> je libovolné celé číslo, je alternativou k <code>add_button(button_text="text", response_id=Gtk.ResponseType.RESPONSE)</code>, kde <code>RESPONSE</code> by bylo jedno z <code>OK, CANCEL, CLOSE, YES, NO, APPLY, HELP</code>, což zase odpovídá celým číslům <code>-5, -6, …, -11</code>.

note: (itstool) path: page/p
en: A dialog with the response signal hooked up to a callback function.
cs: Dialogové okno reagující na signál zaháčkovaný na funkci zpětného volání.

note: (itstool) path: page/code
en: 
    /* A window in the application. */
    public class MyWindow : Gtk.ApplicationWindow {
    
    	/* Constructor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "GNOME Button");
    
    		this.window_position = Gtk.WindowPosition.CENTER;
    		this.set_default_size (250,50);
    
    		var button = new Gtk.Button.with_label ("Click Me");
    
    		/* Connect the button's "clicked" signal to
    		 * the signal handler (aka. this.callback function).
    		 */
    		button.clicked.connect (this.on_button_click);
    
    		/* Add the button to this window and show it. */
    		this.add (button);
    		button.show ();
    	}
    
    	/* The signal handler for the buttons 'clicked' signal. */
    	void on_button_click (Gtk.Button button) {
    		var dialog = new Gtk.Dialog.with_buttons ("A Gtk+ Dialog", this,
                                                              Gtk.DialogFlags.MODAL,
                                                              Gtk.Stock.OK,
                                                              Gtk.ResponseType.OK, null);
    
    		var content_area = dialog.get_content_area ();
    		var label = new Gtk.Label ("This demonstrates a dialog with a label");
    
    		content_area.add (label);
    
    		/* Connect the 'response' signal of the dialog
    		 * the signal handler.  It is emitted when the dialog's
    		 * OK button is clicked.
    		 */
    		dialog.response.connect (on_response);
    
    		/* Show the dialog and all the widgets. */
    		dialog.show_all ();
    	}
    
    	/* Signal handler for the 'response' signal of the dialog. */
            void on_response (Gtk.Dialog dialog, int response_id) {
    
                    /* To see the int value of the ResponseType. This is only
    		 * for demonstration purposes.*/
                    print ("response is %d\n", response_id);
    
    		/* This causes the dialog to be destroyed. */
                    dialog.destroy ();
            }
    
    }
    
    /* This is the application. */
    public class MyApplication : Gtk.Application {
    
    	/* The constructor of the application. */
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    
    		/* Create a window for the this application and show it. */
    		new MyWindow (this).show ();
    	}
    }
    
    /* The main function creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: 
    /* Okno v aplikaci */
    public class MyWindow : Gtk.ApplicationWindow {
    
    	/* Konstruktor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "GNOME Button");
    
    		this.window_position = Gtk.WindowPosition.CENTER;
    		this.set_default_size (250,50);
    
    		var button = new Gtk.Button.with_label ("Click Me");
    
    		/* Napojí signál "clicked" tlačítka
    		 * na obsluhu signálu (neboli funkci zpětného volání)
    		 */
    		button.clicked.connect (this.on_button_click);
    
    		/* Přidá tlačítko do tohoto okna a zobrazí jej */
    		this.add (button);
    		button.show ();
    	}
    
    	/* Zpracování signálu pro signál "clicked" tlačítek */
    	void on_button_click (Gtk.Button button) {
    		var dialog = new Gtk.Dialog.with_buttons ("A Gtk+ Dialog", this,
                                                              Gtk.DialogFlags.MODAL,
                                                              Gtk.Stock.OK,
                                                              Gtk.ResponseType.OK, null);
    
    		var content_area = dialog.get_content_area ();
    		var label = new Gtk.Label ("This demonstrates a dialog with a label");
    
    		content_area.add (label);
    
    		/* Napojí signál "response" dialogového okna
    		 * na zpracování signálu. Signál je vyslán, kdy je kliknuto
    		 * na tlačítko OK v dialogovém okně
    		 */
    		dialog.response.connect (on_response);
    
    		/* Zobrazí dialogové okno a všechny jeho widgety */
    		dialog.show_all ();
    	}
    
    	/* Zpracování signálu pro signál "response" dialogového okna */
            void on_response (Gtk.Dialog dialog, int response_id) {
    
                    /* Zobrazí celočíselnou hodnotu ResponseType. Slouží jen
    		 * pro ukázkové účely */
                    print ("response is %d\n", response_id);
    
    		/* Způsobí likvidaci dialogového okna */
                    dialog.destroy ();
            }
    
    }
    
    /* Toto je aplikace */
    public class MyApplication : Gtk.Application {
    
    	/* Konstruktor aplikace */
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    
    	/* Přepíše signál "activate" z GLib.Application */
    	protected override void activate () {
    
    		/* Vytvoří okno pro tuto aplikaci a zobrazí jej */
    		new MyWindow (this).show ();
    	}
    }
    
    /* Funkce main vytvoří a spustí aplikaci */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: A single line text entry field
cs: Jednořádkové textové vstupní pole

note: (itstool) path: page/p
en: This application greets you in the terminal.
cs: Tato aplikace vás přivítá v terminálu.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /*This is the callback function. It is a handler function 
    which reacts to the signal. In this case, it will grab the 
    text input from the entry box and print out a line to the user.*/
    static void
    on_activate (GtkEntry *entry,
                 gpointer  user_data)
    {
      const char *name;
      name = gtk_entry_get_text (entry);
    
      g_print ("\nHello %s!\n\n", name);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *entry_box;
    
      /*Create a window with a title, a default size, 
      and a set border width*/
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "What is your name?");
      gtk_window_set_default_size (GTK_WINDOW (window), 300, 100);
      gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
      /*Create a new entry box, and add it to the window*/
      entry_box = gtk_entry_new ();
      gtk_container_add (GTK_CONTAINER (window), entry_box);
    
      /*Connecting the activate signal to the callback*/
      g_signal_connect (GTK_ENTRY (entry_box), "activate", 
                        G_CALLBACK (on_activate), NULL);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Toto je funkce zpětného volání. Jedná se o zpracující funkci, 
       která reaguje na signál. V tomto případě zachytává textový 
       vstup ze vstupního pole a vypíše jej uživateli na řádek. */
    static void
    on_activate (GtkEntry *entry,
                 gpointer  user_data)
    {
      const char *name;
      name = gtk_entry_get_text (entry);
    
      g_print ("\nHello %s!\n\n", name);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *entry_box;
    
      /* Vytvoří okno s názvem a výchozí velikostí a nastaví mu okraj */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "What is your name?");
      gtk_window_set_default_size (GTK_WINDOW (window), 300, 100);
      gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
      /* Vytvoří nové vstupní pole a přidá jej do okna */
      entry_box = gtk_entry_new ();
      gtk_container_add (GTK_CONTAINER (window), entry_box);
    
      /* Napojí signál "activate" na zpětné volání */
      g_signal_connect (GTK_ENTRY (entry_box), "activate", 
                        G_CALLBACK (on_activate), NULL);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: info/desc
en: A single-line text entry field
cs: Jednořádkové textové vstupní pole

note: (itstool) path: page/p
en: This application greets you by name through a pop-up window.
cs: Tato aplikace vás přivítá jménem ve vyskakovacím okně.

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class EntryExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsentry',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 100,
                default_width: 300,
                border_width: 10,
                title: "What is your name?"});
    
            // Create the text entry box
            this.entry = new Gtk.Entry ();
            this._window.add(this.entry);
    
            // Connect the text entry box to a function that responds to what you type in
            this.entry.connect("activate", this._hello.bind(this));
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _hello() {
    
            // Create a popup dialog to greet the person who types in their name
            this._greeter = new Gtk.MessageDialog ({
                transient_for: this._window,
                modal: true,
                text: "Hello, " + this.entry.get_text() + "!",
                message_type: Gtk.MessageType.OTHER,
                buttons: Gtk.ButtonsType.OK,
            });
    
            // Show the popup dialog
            this._greeter.show();
    
            // Bind the OK button to the function that closes the popup
            this._greeter.connect ("response", this._okClicked.bind(this));
        }
    
        _okClicked() {
            this._greeter.destroy();
        }
    
    };
    
    // Run the application
    let app = new EntryExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class EntryExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsentry',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 100,
                default_width: 300,
                border_width: 10,
                title: "What is your name?"});
    
            // Vytvoří textové vstupní pole
            this.entry = new Gtk.Entry ();
            this._window.add(this.entry);
    
            // Napojí textové vstupní pole na funkci, která reaguje na to, co napíšete
            this.entry.connect("activate", this._hello.bind(this));
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _hello() {
    
            // Vytvoří vyskakovací dialogové okno, které přivítá osobu, co napsala své jméno
            this._greeter = new Gtk.MessageDialog ({
                transient_for: this._window,
                modal: true,
                text: "Hello, " + this.entry.get_text() + "!",
                message_type: Gtk.MessageType.OTHER,
                buttons: Gtk.ButtonsType.OK,
            });
    
            // Zobrazí dialogové okno
            this._greeter.show();
    
            // Napojí tlačítko OK na funkci, která zavírá dialogové okno
            this._greeter.connect ("response", this._okClicked.bind(this));
        }
    
        _okClicked() {
            this._greeter.destroy();
        }
    
    };
    
    // Spustí aplikaci
    let app = new EntryExample ();
    app.application.run (ARGV);

note: (itstool) path: page/p
en: This application greets you in the terminal with the name you provide.
cs: Tato aplikace vás přivítá v terminálu jménem, které zadáte.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="What is your name?", application=app)
            self.set_default_size(300, 100)
            self.set_border_width(10)
    
            # a single line entry
            name_box = Gtk.Entry()
            # emits a signal when the Enter key is pressed, connected to the
            # callback function cb_activate
            name_box.connect("activate", self.cb_activate)
    
            # add the Gtk.Entry to the window
            self.add(name_box)
    
        # the content of the entry is used to write in the terminal
        def cb_activate(self, entry):
            # retrieve the content of the widget
            name = entry.get_text()
            # print it in a nice form in the terminal
            print("Hello " + name + "!")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="What is your name?", application=app)
            self.set_default_size(300, 100)
            self.set_border_width(10)
    
            # Jednořádkové vstupní pole
            name_box = Gtk.Entry()
            # Vyšle signál, když je zmáčknuta klávesa Enter, napojený na
            # funkci zpětného volání cb_activate
            name_box.connect("activate", self.cb_activate)
    
            # Přidá Gtk.Entry do okna
            self.add(name_box)
    
        # the content of the entry is used to write in the terminal
        def cb_activate(self, entry):
            # Získá obsah widgetu
            name = entry.get_text()
            # Vypíše jej v hezké podobě do terminálu
            print("Hello " + name + "!")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for an Entry widget
cs: Užitečné metody pro widget Entry

note: (itstool) path: section/p
en: In line 14 the signal <code>"activate"</code> is connected to the callback function <code>cb_activate()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation. Some of the signals that a Gtk.Entry widget can emit are: <code>"activate"</code> (emitted when the user activates the Entry key); <code>"backspace"</code> (emitted when the user activates the Backspace or Shift-Backspace keys); <code>"copy-clipboard"</code> (Ctrl-c and Ctrl-Insert); <code>"paste-clipboard"</code> (Ctrl-v and Shift-Insert); <code>"delete-from-cursor"</code> (Delete, for deleting a character; Ctrl-Delete, for deleting a word); <code>"icon-press"</code> (emitted when the user clicks an activatable icon); <code>"icon-release"</code> (emitted on the button release from a mouse click over an activatable icon); <code>"insert-at-cursor"</code> (emitted when the user initiates the insertion of a fixed string at the cursor); <code>"move-cursor"</code> (emitted when the user initiates a cursor movement); <code>"populate-popup"</code> (emitted before showing the context menu of the entry; it can be used to add items to it).
cs: Na řádku 14 je signál <code>"activate"</code> napojen na funkci zpětného volání <code>cb_activate()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce_zpětného_volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>. Mezi signály, které widget <code>Gtk.Entry</code> umí vyslat patří: <code>"activate"</code> (vyšle, když uživatel použije klávesu Enter); <code>"backspace"</code> (vyšle, když uživatel použije klávesu Backspace nebo Shift-Backspace); <code>"copy-clipboard"</code> (Ctrl-c a Ctrl-Insert); <code>"paste-clipboard"</code> (Ctrl-v a Shift-Insert); <code>"delete-from-cursor"</code> (Delete pro mazání znaku; Ctrl-Delete pro mazání slova); <code>"icon-press"</code> (vyšle, když uživatel klikne na aktivovatelné ikoně); <code>"icon-release"</code> (vyšle při uvolnění tlačítka z kliknutí myší na aktivovatelné ikoně); <code>"insert-at-cursor"</code> (vyšle, když uživatel začne vkládat pevný řetězec na pozici kurzoru); <code>"move-cursor"</code> (vyšle, když uživatel začne posouvat kurzor); <code>"populate-popup"</code> (vyšle před zobrazením kontextové nabídky pole; může být použito k přidání položek do ní).

note: (itstool) path: item/p
en: <code>get_buffer()</code> and <code>set_buffer(buffer)</code>, where <code>buffer</code> is a Gtk.EntryBuffer object, can be used to get and set the buffer for the entry.
cs: <code>get_buffer()</code> a <code>set_buffer(vyrovnávací_paměť)</code>, kde <code>vyrovnávací_paměť</code> je objekt Gtk.EntryBuffer, můžete použít k získání a nastavení vyrovnávací paměti pro vstupní pole.

note: (itstool) path: item/p
en: <code>get_text()</code> and <code>set_text("some text")</code> can be used to get and set the content for the entry.
cs: <code>get_text()</code> a <code>set_text("nějaký text")</code> můžete použít k získání a nastavení obsahu vstupního pole.

note: (itstool) path: item/p
en: <code>get_text_length()</code> is self-explanatory.
cs: <code>get_text_length()</code> vrací délku textu.

note: (itstool) path: item/p
en: <code>get_text_area()</code> gets the area where the entry's text is drawn.
cs: <code>get_text_area()</code> vrací oblast, ve které je textové vstupní pole vykreslováno.

note: (itstool) path: item/p
en: If we set <code>set_visibility(False)</code> the characters in the entry are displayed as the invisible char. This is the best available in the current font, but it can be changed with <code>set_invisible_char(ch)</code>, where <code>ch</code> is a Unicode character. The latter method is reversed by <code>unset_invisible_char()</code>.
cs: Když nastavíme <code>set_visibility(False)</code>, jsou znaky v poli zobrazovány pomocí „neviditelného“ znaku. Je zvolen nejlépe dostupný v aktuálním písmu, ale můžete jej změnit na jiný pomocí <code>set_invisible_char(zn)</code>, kde <code>zn</code> je znak v Unikódu. Později lze změnu zvrátit použitím <code>unset_invisbile_char()</code>.

note: (itstool) path: item/p
en: <code>set_max_length(int)</code>, where <code>int</code> is an integer, truncates every entry longer than <code>int</code> to have the desired maximum length.
cs: <code>set_max_length(int)</code>, kde <code>int</code> je celé číslo, zkrátí každý vstup delší než <code>int</code> na požadovanou maximální délku.

note: (itstool) path: item/p
en: By default, if you press the Entry key the Gtk.Entry emits the signal <code>"activate"</code>. If you would like to activate the default widget for the window (set using <code>set_default(widget)</code> on the window), then use <code>set_activates_default(True)</code>.
cs: Ve výchozím stavu, když zmáčknete klávesu <key>Enter</key>, vyšle Gtk.Entry signál <code>"activate"</code>. Pokud byste chtěli aktivovat výchozí widget okna (nastavený pomocí metody <code>set_default(widget)</code> okna), použijte <code>set_activates_default(True)</code>.

note: (itstool) path: item/p
en: To set a frame around the entry: <code>set_has_frame(True)</code>.
cs: Pro nastavení rámečku okolo vstupního pole: <code>set_has_frame(True)</code>.

note: (itstool) path: item/p
en: <code>set_placeholder_text("some text")</code> sets the text to be displayed in the entry when it is empty and unfocused.
cs: <code>set_placeholder_text("nějaký text")</code> nastavuje text, který má být zobrazen ve vstupním poli, když je prázdné a nezaměřené.

note: (itstool) path: item/p
en: <code>set_overwrite_mode(True)</code> and <code>set_overwrite_mode(False)</code> are self-explanatory.
cs: <code>set_overwrite_mode(True)</code> a <code>set_overwrite_mode(False)</code> zapíná/vypíná režim přepisování.

note: (itstool) path: item/p
en: If we have <code>set_editable(False)</code> the user cannot edit the text in the widget.
cs: Když je nastaveno <code>set_editable(False)</code>, nemůže uživatel upravovat text ve widgetu.

note: (itstool) path: item/p
en: <code>set_completion(completion)</code>, where <code>completion</code> is a <link href="http://developer.gnome.org/gtk3/unstable/GtkEntryCompletion.html"><code>Gtk.EntryCompletion</code></link>, sets completion - or disables it if <code>completion</code> is <code>None</code>.
cs: <code>set_completion(doplňování)</code>, kde <code>doplňování</code> je <link href="http://developer.gnome.org/gtk3/unstable/GtkEntryCompletion.html"><code>Gtk.EntryCompletion</code></link>, nastaví doplňování, nebo jej naopak zakáže, když je <code>doplňování</code> nastaveno na <code>None</code>.

note: (itstool) path: item/p
en: An Entry widget can display progress or activity information behind the text. We use <code>set_progress_fraction(fraction)</code>, where <code>fraction</code> is a <code>float</code> between <code>0.0</code> and <code>1.0</code> inclusive, to fill in the given fraction of the bar. We use <code>set_progress_pulse_step()</code> to set the fraction of total entry width to move the progress bouncing block for each call to <code>progress_pulse()</code>. The latter method indicates that some progress is made, and causes the progress indicator of the entry to enter "activity mode", where a block bounces back and forth. Each call to <code>progress_pulse()</code> causes the block to move by a little bit (the amount of movement per pulse is determined, as said before, by <code>set_progress_pulse_step()</code>).
cs: Widget <code>Entry</code> může na pozadí textu zobrazovat průběh nebo aktivitu. K vyplnění zadané části pruhu používáme <code>set_progress_fraction(část)</code>, <code>část</code> je číslo typu <code>float</code> v rozmezí <code>0.0</code> až <code>1.0</code> včetně. <code>set_progress_pulse_step()</code> používáme k nastavení části celkové délky pole, která se má pohybovat jako poletující blok ukazatele průběhu při každém zavolání <code>progress_pulse()</code>. Poslední zmíněná metoda dává najevo, že byl učiněn nějaký pokrok a způsobí, že indikátor ukazatele průběhu vstoupí do aktivního režimu, kdy blok poletuje tam a zpět. Každé zavolání <code>progress_pulse()</code> způsobí, že se blok o kousek posune (o kolik přesně je určeno, jak již bylo řečeno, pomocí <code>set_progress_pulse_step()</code>).

note: (itstool) path: item/p
en: An Entry widget can also show icons. These icons can be activatable by clicking, can be set up as drag source and can have tooltips. To add an icon, use <code>set_icon_from_stock(icon_position, stock_id)</code>, or one of <code>set_icon_from_pixbuf(icon_position, pixbuf)</code>, <code>set_icon_from_icon_name(icon_position, icon_name)</code>, where <code>icon_position</code> is one of <code>Gtk.EntryIconPosition.PRIMARY</code> (to set the icon at the beginning of the entry) <code>Gtk.EntryIconPosition.SECONDARY</code> (to set the icon at the end of the entry). To set a tooltip on an icon, use <code>set_icon_tooltip_text("tooltip text")</code> or <code>set_icon_tooltip_markup("tooltip text in Pango markup language")</code>.
cs: Widget <code>Entry</code> může také zobrazovat ikony. Tyto ikony, které lze aktivovat kliknutí, mohou být nastaveny jako zdroj pro přetahování a mohou mít vysvětlivky. Pro přidání ikony použijte <code>set_icon_from_stock(pozice_ikony, standardní_id)</code> nebo některou z funkcí <code>set_icon_from_pixbuf(pozice_ikony, pixbuf)</code>, <code>set_icon_from_icon_name(pozicei_kony, název_ikony)</code>, kde <code>pozice_ikony</code> je něco z <code>Gtk.EntryIconPosition.PRIMARY</code> (vytvoří ikonu na začátek vstupního pole) nebo <code>Gtk.EntryIconPosition.SECONDARY</code> (vytvoří ikonu na konci vstupního pole). Pro nastavení vysvětlivky ikoně použijte <code>set_icon_tooltip_text("text vysvětlivky")</code> nebo <code>set_icon_tooltip_markup("text vysvětlivky ve značkovacím jazyce Pango")</code>.

note: (itstool) path: page/code
en: /* A window in the application. */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* Constructor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "What is your name?");
    
    		var name_box = new Gtk.Entry ();
    
    		/* Connect to the signal handler. */
    		name_box.activate.connect (this.on_activate);
    		name_box.show ();
    
    		this.set_default_size (300, 100);
    		this.border_width = 10;
    
    		/* Add the name_box to this window. */
    		this.add (name_box);
    	}
    
    	/* Signal handler (aka. callback function) for the 'activate'
    	 * signal of a Gtk.Entry.
    	 */
    	void on_activate (Gtk.Entry entry) {
    		name = entry.get_text ();
    		print ("\nHello " + name + "!\n\n");
    	}
    }
    
    /* This is the application. */
    class MyApplication : Gtk.Application {
    
    	/* Constructor for the application. */
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    
    		/* Create a new window for this application
    		 * and show it. */
    		new MyWindow (this).show ();
    	}
    
    }
    
    /* The main function creates and runs the application. */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Okno v aplikaci */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* Konstruktor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "What is your name?");
    
    		var name_box = new Gtk.Entry ();
    
    		/* Napojí na obsluhu signálu */
    		name_box.activate.connect (this.on_activate);
    		name_box.show ();
    
    		this.set_default_size (300, 100);
    		this.border_width = 10;
    
    		/* Přidá name_box do tohoto okna */
    		this.add (name_box);
    	}
    
    	/* Zpracování signálu (neboli funkce zpětného volání) pro
    	 * signál "activate" z Gtk.Entry
    	 */
    	void on_activate (Gtk.Entry entry) {
    		name = entry.get_text ();
    		print ("\nHello " + name + "!\n\n");
    	}
    }
    
    /* Toto je aplikace */
    class MyApplication : Gtk.Application {
    
    	/* Konstruktor aplikace */
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    
    	/* Přepíše signál "activate" z GLib.Application */
    	protected override void activate () {
    
    		/* Vytvoří okno pro tuto aplikaci a zobrazí jej */
    		new MyWindow (this).show ();
    	}
    
    }
    
    /* Funkce main vytvoří a spustí aplikaci */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: A dialog suitable for "Open" and "Save" commands
cs: Dialogové okno vhodné pro příkazy „Otevřít“ a „Uložit“

note: (itstool) path: page/p
en: This FileChooserDialog saves a text document, which can be opened or written from scratch in a TextView (see below).
cs: Tento FileChooserDialog ukládá textové dokumenty, které mohou být otevřeny nebo napsány od nuly v TextView (viz dále).

note: (itstool) path: page/p
en: It is also possible to call a FileChooserDialog to open a new document.
cs: Je také možné zavolat FileChooserDialog pro otevření nového dokumentu.

note: (itstool) path: section/title
en: Steps to recreate the example
cs: Kroky k reprodukci příkladu

note: (itstool) path: item/p
en: Create a file .ui to describe an app-menu with items "New", "Open", "Save", "Save as", and "Quit". This can be done with Glade or in a text editor. See <link xref="#xml"/>
cs: Vytvořte soubor .ui, který bude popisovat aplikační nabídku s položkami „New“, „Open“, „Save“, „Save As“ a „Quit“. To můžete udělat v Glade nebo v textovém editoru. Viz <link xref="#xml"/>.

note: (itstool) path: item/p
en: Create a Python program for a Gtk.TextView with a Gtk.Buffer <code>self.buffer</code>, and a <code>self.file</code> which will be a Gio.File and we set initially as <code>None</code>.
cs: Vytvořte program v jazyce Python pro Gtk.TextView s Gtk.Buffer <code>self.buffer</code> a <code>self.file</code>, což bude Gio.File nastavený na počátku na <code>None</code>.

note: (itstool) path: item/p
en: In this program, create also the actions corresponding to the items in the app-menu, connect them to callback functions, and import the menu in the <code>do_startup()</code> method with a Gtk.Builder.
cs: V tomto programu vytvoříme také akce odpovídající položkám v aplikační nabídce, napojíme je na funkce zpětného volání a naimportujeme nabídku pomocí metody <code>do_startup()</code> třídy <code>Gtk.Builder</code>.

note: (itstool) path: item/p
en: "New" and "Quit" actions and callback functions are quite straightforward, see <link xref="#code"/>. See <link xref="signals-callbacks.py"/> for a more detailed explanation of signals and callback functions.
cs: Akce <gui>New</gui> a <gui>Quit</gui> a jejich funkce zpětného volání jsou velmi jednoduché, viz <link xref="#code"/>. Podrobnější vysvětlení signálů a funkcí zpětného volání najdete v <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: "Open" callback should create and open a Gtk.FileChooserDialog for "Open", connected with another callback function for each of the two "Open" and "Cancel" buttons of the FileChooserDialog.
cs: Zpětné volání akce <gui>Open</gui> by mělo vytvořit a otevřít <code>Gtk.FileChooserDialog</code> pro otevření souboru. Toto dialogové okno je napojeno na jiné funkce zpětného volání, jednu pro tlačítko <gui>Open</gui> a druhou pro tlačítko <gui>Cancel</gui> dialogového okna.

note: (itstool) path: item/p
en: "Save as" works basically as "Open", but the callback function of the "Save" button depends on a more complex method <code>save_to_file()</code>.
cs: Akce <gui>Save as</gui> funguje podobně jako <gui>Open</gui>, akorát funkce zpětného volání pro tlačítko <gui>Save</gui> závisí na mnohem komplexnější metodě <code>save_to_file()</code>.

note: (itstool) path: item/p
en: "Save" can be reduced to the case where the file is <code>None</code>, that is the case where <code>self.file</code> is a new file, which in turn is the case "Save as"; and to the case where the file is not <code>None</code>, which in turn is reduced to <code>save_to_file()</code>.
cs: Akci <gui>Save</gui> lze zúžit na případ, kdy soubor je <code>None</code>, což je případ, kdy <code>self.file</code> je nový soubor, a tím pádem to změníme na akci <gui>Save as</gui>, a případ, kdy soubor není <code>None</code>, což se zúží na <code>save_to_file()</code>.

note: (itstool) path: item/p
en: Finally, the method <code>save_to_file()</code>: see <link xref="#code"/>, lines 146 - 175.
cs: A nakonec metoda <code>save_to_file()</code>: viz <link xref="#code"/>, řádky 146 – 175.

note: (itstool) path: section/title
en: XML file which creates the app-menu
cs: Soubor XML, který vytváří nabídku aplikace

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Gdk
    from gi.repository import Gio
    from gi.repository import GObject
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(
                self, title="FileChooserDialog Example", application=app)
            self.set_default_size(400, 400)
    
            # the actions for the window menu, connected to the callback functions
            new_action = Gio.SimpleAction.new("new", None)
            new_action.connect("activate", self.new_callback)
            self.add_action(new_action)
    
            open_action = Gio.SimpleAction.new("open", None)
            open_action.connect("activate", self.open_callback)
            self.add_action(open_action)
    
            save_action = Gio.SimpleAction.new("save", None)
            save_action.connect("activate", self.save_callback)
            self.add_action(save_action)
    
            save_as_action = Gio.SimpleAction.new("save-as", None)
            save_as_action.connect("activate", self.save_as_callback)
            self.add_action(save_as_action)
    
            # the file
            self.file = None
    
            # the textview with the buffer
            self.buffer = Gtk.TextBuffer()
            textview = Gtk.TextView(buffer=self.buffer)
            textview.set_wrap_mode(Gtk.WrapMode.WORD)
    
            # a scrolled window for the textview
            self.scrolled_window = Gtk.ScrolledWindow()
            self.scrolled_window.set_policy(
                Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
            self.scrolled_window.add(textview)
            self.scrolled_window.set_border_width(5)
    
            # add the scrolled window to the window
            self.add(self.scrolled_window)
    
        # callback for new
        def new_callback(self, action, parameter):
            self.buffer.set_text("")
            print("New file created")
    
        # callback for open
        def open_callback(self, action, parameter):
            # create a filechooserdialog to open:
            # the arguments are: title of the window, parent_window, action,
            # (buttons, response)
            open_dialog = Gtk.FileChooserDialog("Pick a file", self,
                                                Gtk.FileChooserAction.OPEN,
                                               (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
                                                Gtk.STOCK_OPEN, Gtk.ResponseType.ACCEPT))
    
            # not only local files can be selected in the file selector
            open_dialog.set_local_only(False)
            # dialog always on top of the textview window
            open_dialog.set_modal(True)
            # connect the dialog with the callback function open_response_cb()
            open_dialog.connect("response", self.open_response_cb)
            # show the dialog
            open_dialog.show()
    
        # callback function for the dialog open_dialog
        def open_response_cb(self, dialog, response_id):
            open_dialog = dialog
            # if response is "ACCEPT" (the button "Open" has been clicked)
            if response_id == Gtk.ResponseType.ACCEPT:
                # self.file is the file that we get from the FileChooserDialog
                self.file = open_dialog.get_file()
                # an empty string (provisionally)
                content = ""
                try:
                    # load the content of the file into memory:
                    # success is a boolean depending on the success of the operation
                    # content is self-explanatory
                    # etags is an entity tag (can be used to quickly determine if the
                    # file has been modified from the version on the file system)
                    [success, content, etags] = self.file.load_contents(None)
                except GObject.GError as e:
                    print("Error: " + e.message)
                # set the content as the text into the buffer
                self.buffer.set_text(content, len(content))
                print("opened: " + open_dialog.get_filename())
            # if response is "CANCEL" (the button "Cancel" has been clicked)
            elif response_id == Gtk.ResponseType.CANCEL:
                print("cancelled: FileChooserAction.OPEN")
            # destroy the FileChooserDialog
            dialog.destroy()
    
        # callback function for save_as
        def save_as_callback(self, action, parameter):
            # create a filechooserdialog to save:
            # the arguments are: title of the window, parent_window, action,
            # (buttons, response)
            save_dialog = Gtk.FileChooserDialog("Pick a file", self,
                                                Gtk.FileChooserAction.SAVE,
                                               (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
                                                Gtk.STOCK_SAVE, Gtk.ResponseType.ACCEPT))
            # the dialog will present a confirmation dialog if the user types a file name that
            # already exists
            save_dialog.set_do_overwrite_confirmation(True)
            # dialog always on top of the textview window
            save_dialog.set_modal(True)
            # if self.file has already been saved
            if self.file is not None:
                try:
                    # set self.file as the current filename for the file chooser
                    save_dialog.set_file(self.file)
                except GObject.GError as e:
                    print("Error: " + e.message)
            # connect the dialog to the callback function save_response_cb()
            save_dialog.connect("response", self.save_response_cb)
            # show the dialog
            save_dialog.show()
    
        # callback function for the dialog save_dialog
        def save_response_cb(self, dialog, response_id):
            save_dialog = dialog
            # if response is "ACCEPT" (the button "Save" has been clicked)
            if response_id == Gtk.ResponseType.ACCEPT:
                # self.file is the currently selected file
                self.file = save_dialog.get_file()
                # save to file (see below)
                self.save_to_file()
            # if response is "CANCEL" (the button "Cancel" has been clicked)
            elif response_id == Gtk.ResponseType.CANCEL:
                print("cancelled: FileChooserAction.SAVE")
            # destroy the FileChooserDialog
            dialog.destroy()
    
        # callback function for save
        def save_callback(self, action, parameter):
            # if self.file is not already there
            if self.file is not None:
                self.save_to_file()
            # self.file is a new file
            else:
                # use save_as
                self.save_as_callback(action, parameter)
    
        # save_to_file
        def save_to_file(self):
            # get the content of the buffer, without hidden characters
            [start, end] = self.buffer.get_bounds()
            current_contents = self.buffer.get_text(start, end, False)
            # if there is some content
            if current_contents != "":
                # set the content as content of self.file.
                # arguments: contents, etags, make_backup, flags, GError
                try:
                    self.file.replace_contents(current_contents,
                                               None,
                                               False,
                                               Gio.FileCreateFlags.NONE,
                                               None)
                    print("saved: " + self.file.get_path())
                except GObject.GError as e:
                    print("Error: " + e.message)
            # if the contents are empty
            else:
                # create (if the file does not exist) or overwrite the file in readwrite mode.
                # arguments: etags, make_backup, flags, GError
                try:
                    self.file.replace_readwrite(None,
                                                False,
                                                Gio.FileCreateFlags.NONE,
                                                None)
                    print("saved: " + self.file.get_path())
                except GObject.GError as e:
                    print("Error: " + e.message)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # app action quit, connected to the callback function
            quit_action = Gio.SimpleAction.new("quit", None)
            quit_action.connect("activate", self.quit_callback)
            self.add_action(quit_action)
    
            # get the menu from the ui file with a builder
            builder = Gtk.Builder()
            try:
                builder.add_from_file("filechooserdialog.ui")
            except:
                print("file not found")
                sys.exit()
            menu = builder.get_object("appmenu")
            self.set_app_menu(menu)
    
        # callback function for quit
        def quit_callback(self, action, parameter):
            self.quit()
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Gdk
    from gi.repository import Gio
    from gi.repository import GObject
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(
                self, title="FileChooserDialog Example", application=app)
            self.set_default_size(400, 400)
    
            # Akce pro nabídku okna, napojí se na funkci zpětného volání
            new_action = Gio.SimpleAction.new("new", None)
            new_action.connect("activate", self.new_callback)
            self.add_action(new_action)
    
            open_action = Gio.SimpleAction.new("open", None)
            open_action.connect("activate", self.open_callback)
            self.add_action(open_action)
    
            save_action = Gio.SimpleAction.new("save", None)
            save_action.connect("activate", self.save_callback)
            self.add_action(save_action)
    
            save_as_action = Gio.SimpleAction.new("save-as", None)
            save_as_action.connect("activate", self.save_as_callback)
            self.add_action(save_as_action)
    
            # Soubor
            self.file = None
    
            # TextView s vyrovnávací pamětí
            self.buffer = Gtk.TextBuffer()
            textview = Gtk.TextView(buffer=self.buffer)
            textview.set_wrap_mode(Gtk.WrapMode.WORD)
    
            # Okno s posuvníky pro TextView
            self.scrolled_window = Gtk.ScrolledWindow()
            self.scrolled_window.set_policy(
                Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
            self.scrolled_window.add(textview)
            self.scrolled_window.set_border_width(5)
    
            # Přidá okno s posuvníky do okna
            self.add(self.scrolled_window)
    
        # Zpětné volání pro "new"
        def new_callback(self, action, parameter):
            self.buffer.set_text("")
            print("New file created")
    
        # Zpětné volání pro "open"
        def open_callback(self, action, parameter):
            # Vytvoří FileChooserDialog pro otevření
            # argumenty jsou: název okna, rodičovské okno, akce,
            # (tlačítka, odpověď)
            open_dialog = Gtk.FileChooserDialog("Pick a file", self,
                                                Gtk.FileChooserAction.OPEN,
                                               (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
                                                Gtk.STOCK_OPEN, Gtk.ResponseType.ACCEPT))
    
            # Lze vybírat nejen místní soubory
            open_dialog.set_local_only(False)
            # Dialogové okno bude vždy nad oknem s TextView
            open_dialog.set_modal(True)
            # Napojí dialogové okno na funci zpětného volání open_response_cb()
            open_dialog.connect("response", self.open_response_cb)
            # Zobrazí dialogové okno
            open_dialog.show()
    
        # Funkce zpětného volání pro dialogové okno open_dialog
        def open_response_cb(self, dialog, response_id):
            open_dialog = dialog
            # Pokud odpověď je "ACCEPT" (bylo kliknuto na tlačítko "Open")
            if response_id == Gtk.ResponseType.ACCEPT:
                # self.file je soubor, který jsme od FileChooserDialog dostali
                self.file = open_dialog.get_file()
                # Prázdný řetězec (prozatímně)
                content = ""
                try:
                    # Načte obsah souboru do paměti
                    # success: pravdivostní hodnota závisející na úspěchu operace
                    # content: obsah
                    # etags: je značka entity (může být použit k rychlému určení, jestli
                    # byl soubor změněn vůči verzi v souborovém systému)
                    [success, content, etags] = self.file.load_contents(None)
                except GObject.GError as e:
                    print("Error: " + e.message)
                # Nastaví obsah jako text do vyrovnávací paměti
                self.buffer.set_text(content, len(content))
                print("opened: " + open_dialog.get_filename())
            # Pokud odpověď je "CANCEL" (vylo kliknuto na tlačítko "Cancel")
            elif response_id == Gtk.ResponseType.CANCEL:
                print("cancelled: FileChooserAction.OPEN")
            # Zlikviduje FileChooserDialog
            dialog.destroy()
    
        # Funkce zpětného volání pro "save_as"
        def save_as_callback(self, action, parameter):
            # Vytvoří FileChooserDialog pro uložení
            # argumenty jsou: název okna, rodičovské okno, akce,
            # (tlačítka, odpověď)
            save_dialog = Gtk.FileChooserDialog("Pick a file", self,
                                                Gtk.FileChooserAction.SAVE,
                                               (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
                                                Gtk.STOCK_SAVE, Gtk.ResponseType.ACCEPT))
            # Pokud uživatel zadá název souboru, který již existuje, zobrazí dialogové okno
            # dotaz na potvrzení
            save_dialog.set_do_overwrite_confirmation(True)
            # Dialogové okno bude vždy nad oknem s TextView
            save_dialog.set_modal(True)
            # Pokud byl self.file již uložen
            if self.file is not None:
                try:
                    # Nastaví self.file jako aktuální název do výběru souboru
                    save_dialog.set_file(self.file)
                except GObject.GError as e:
                    print("Error: " + e.message)
            # Napojí dialogové okno na funkci zpětného volání save_response_cb()
            save_dialog.connect("response", self.save_response_cb)
            # Zobrazí dialogové okno
            save_dialog.show()
    
        # Funkce zpětného volání pro dialogové okno save_dialog
        def save_response_cb(self, dialog, response_id):
            save_dialog = dialog
            # Pokud odpověď je "ACCEPT" (bylo kliknuto na tlačítko "Save")
            if response_id == Gtk.ResponseType.ACCEPT:
                # self.file je aktuálně vybraný soubor
                self.file = save_dialog.get_file()
                # Uloží do souboru (viz níže)
                self.save_to_file()
            # Pokud odpověď je "CANCEL" (bylo kliknuto na tlačítko "Cancel")
            elif response_id == Gtk.ResponseType.CANCEL:
                print("cancelled: FileChooserAction.SAVE")
            # Zlikviduje FileChooserDialog
            dialog.destroy()
    
        # Funkce zpětného volání pro uložení
        def save_callback(self, action, parameter):
            # Pokud tam self.file zatím není
            if self.file is not None:
                self.save_to_file()
            # self.file je nový soubor
            else:
                # Použije save_as
                self.save_as_callback(action, parameter)
    
        # Uložení do souboru
        def save_to_file(self):
            # Získá obsah vyrovnávací paměti, bez skrytých znaků
            [start, end] = self.buffer.get_bounds()
            current_contents = self.buffer.get_text(start, end, False)
            # Pokud je nějaký obsah
            if current_contents != "":
                # Nastaví obsah jako obsah souboru self.file
                # argumenty: obsah, značka entity, vytvořit zálohu?, příznaky, GError
                try:
                    self.file.replace_contents(current_contents,
                                               None,
                                               False,
                                               Gio.FileCreateFlags.NONE,
                                               None)
                    print("saved: " + self.file.get_path())
                except GObject.GError as e:
                    print("Error: " + e.message)
            # Pokud je obsah prázdný
            else:
                # Vytvoří (když soubor neexistuje) nebo přepíše soubor v režimu zápisu
                # argumenty: značka entity, vytvořit zálohu?, příznaky, GError
                try:
                    self.file.replace_readwrite(None,
                                                False,
                                                Gio.FileCreateFlags.NONE,
                                                None)
                    print("saved: " + self.file.get_path())
                except GObject.GError as e:
                    print("Error: " + e.message)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # Akce "quit" aplikace, napojí se na funkci zpětného volání
            quit_action = Gio.SimpleAction.new("quit", None)
            quit_action.connect("activate", self.quit_callback)
            self.add_action(quit_action)
    
            # Získá nabídku ze souboru s UI pomocí Builderu
            builder = Gtk.Builder()
            try:
                builder.add_from_file("filechooserdialog.ui")
            except:
                print("file not found")
                sys.exit()
            menu = builder.get_object("appmenu")
            self.set_app_menu(menu)
    
        # Funkce zpětného volání pro "quit"
        def quit_callback(self, action, parameter):
            self.quit()
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a FileChooserDialog
cs: Užitečné metody pro FileChooserDialog

note: (itstool) path: section/p
en: Note that the action of the FileChooserDialog can be one of the following: <code>Gtk.FileChooserAction.OPEN</code> (the file chooser will only let the user pick an existing file) <code>Gtk.FileChooserAction.SAVE</code> (the file chooser will let the user pick an existing file, or type in a new filename), <code>Gtk.FileChooserAction.SELECT_FOLDER</code> (the file chooser will let the user pick an existing folder), <code>Gtk.FileChooserAction.CREATE_FOLDER</code> (the file chooser will let the user name an existing or new folder).
cs: Poznamenejme, že akce u dialogového okna pro výběr souboru může být některá z následujících: <code>Gtk.FileChooserAction.OPEN</code> (umožní uživateli jen vybrat existující soubor) <code>Gtk.FileChooserAction.SAVE</code> (umožní uživateli vybrat existující soubor nebo napsat název nového), <code>Gtk.FileChooserAction.SELECT_FOLDER</code> (umožní uživateli jen vybrat existující složku), <code>Gtk.FileChooserAction.CREATE_FOLDER</code> (umožní uživateli vybrat existující složku nebo napsat název nové).

note: (itstool) path: section/p
en: Besides the methods used in the <link xref="#code"/>, we have:
cs: Mimo metod použitých v <link xref="#code"/>, máme:

note: (itstool) path: item/p
en: <code>set_show_hidden(True)</code> is used to display hidden files and folders.
cs: <code>set_show_hidden(True)</code> se používá k zobrazení skrytých souborů a složek.

note: (itstool) path: item/p
en: <code>set_select_multiple(True)</code> sets that multiple files can be selected. This is only relevant if the mode is <code>Gtk.FileChooserAction.OPEN</code> or <code>Gtk.FileChooserAction.SELECT_FOLDER</code>.
cs: <code>set_select_multiple(True)</code> nastavuje možnost vybrat více souborů naráz. To má význam jen v případě, že režim je <code>Gtk.FileChooserAction.OPEN</code> nebo <code>Gtk.FileChooserAction.SELECT_FOLDER</code>.

note: (itstool) path: item/p
en: In a "Save as" dialog, <code>set_current_name(current_name)</code> sets <code>current_name</code> in the file selector, as if entered by the user; <code>current_name</code> can be something like <em>Untitled.txt</em>. This method should not be used except in a "Save as" dialog.
cs: V dialogovém okně <gui>Uložení jako</gui> funkce <code>set_current_name(aktuální_název)</code> nastavuje ve výběru souboru <code>aktuální_název</code>, jako by jej zadal uživatel. <code>aktuální_název</code> může být něco jako <em>Untitled.txt</em>. Tato metoda by se neměla používat jinde než pro „Uložit jako“.

note: (itstool) path: item/p
en: The default current folder is "recent items". To set another folder use <code>set_current_folder_uri(uri)</code>; but note you should use this method and cause the file chooser to show a specific folder only when you are doing a "Save as" command and you already have a file saved somewhere.
cs: Výchozí aktuální složkou jsou nedávné položky. Pro nastavení jiné složky použijte <code>set_current_folder_uri(uri)</code>. Upozorňujeme ale, že tuto metodu byste měli použít, a přimět tím výběr souboru zobrazit zadanou složku, jen když provádíte „Uložit jako“ a máte již soubor někde uložený.

note: (itstool) path: info/desc
en: A dialog suitable for "Open" and "Save" commands.
cs: Dialogové okno vhodné pro příkazy „Otevřít“ a „Uložit“.

note: (itstool) path: section/title
en: Overview of the example
cs: Shrnutí příkladu

note: (itstool) path: section/p
en: This example demonstrates how the FileChooserDialog can be used. It is incorporated into a very simple text editor application. All the <link xref="menubar.vala#win-app">actions</link>, including the "open", "save" and "save-as" commands can be found in the <link xref="gmenu.vala">app-menu</link>. Here, the app-menu is created using an XML UI file, which is then imported into the application using Gtk.Builder.
cs: Tento příklad předvádí, jak použít <code>FileChooserDialog</code>. Je začleněn do aplikace velmi jednoduchého textového editoru. Všechny <link xref="menubar.vala#win-app">akce</link>, včetně <code>"open"</code>, <code>"save"</code> a <code>"save-as"</code> najdete v <link xref="gmenu.vala">aplikační nabídce</link>. Zde ji vytvoříme pomocí souboru s uživatelským rozhraním ve formátu XML, který do aplikace naimportujeme pomocí <code>Gtk.Builder</code>.

note: (itstool) path: section/title
en: XML UI file which creates the app-menu
cs: Soubor XML s uživatelským rozhraním, který vytvoří nabídku aplikace

note: (itstool) path: section/title
en: Vala Code
cs: Kód v jazyce Vala

note: (itstool) path: section/code
en: class MyWindow: Gtk.ApplicationWindow {
    
    	/* MyWindow instance variables. */
    	GLib.File? file;
    	Gtk.TextBuffer buffer;
    	Gtk.TextView textview;
    	Gtk.ScrolledWindow scrolled_window;
    
    	/* Create ActionEntries. */
    	const ActionEntry[] actions = {
    		{ "new", new_cb },
    		{ "open", open_cb },
    		{ "save", save_cb },
    		{ "save-as", save_as_cb }
    	};
    
    	/* Constructor creates MyWindow, and add the scrolled_window. */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "FileChooserDialog Example");
    		this.set_default_size (400, 400);
    
    		/* Add the ActionEntries to MyWindow. */
    		this.add_action_entries (actions, this);
    
    		buffer = new Gtk.TextBuffer (null); //stores text to be displayed
    		textview = new Gtk.TextView.with_buffer (buffer); //displays TextBuffer
    		textview.set_wrap_mode (Gtk.WrapMode.WORD); //sets line wrapping
    
    		scrolled_window = new Gtk.ScrolledWindow (null, null);
    		scrolled_window.set_policy (Gtk.PolicyType.AUTOMATIC,
    		                            Gtk.PolicyType.AUTOMATIC);
    
    		scrolled_window.add (textview);
    		scrolled_window.set_border_width (5);
    
            this.add (scrolled_window);
    		this.show_all ();
    	}
    
    	void new_cb (SimpleAction action, Variant? parameter) {
    		file = null;
    		buffer.set_text ("");
    		print ("New file created\n");
    	}
    
    	/* Create FileChooserDialog in OPEN mode. */
    	void open_cb (SimpleAction action, Variant? parameter) {
    
    		var open_dialog = new Gtk.FileChooserDialog ("Pick a file",
    		                                             this as Gtk.Window,
    		                                             Gtk.FileChooserAction.OPEN,
    		                                             Gtk.Stock.CANCEL,
    		                                             Gtk.ResponseType.CANCEL,
    		                                             Gtk.Stock.OPEN,
    		                                             Gtk.ResponseType.ACCEPT);
    
    		open_dialog.local_only = false; //allow for uri
    		open_dialog.set_modal (true);
    		open_dialog.response.connect (open_response_cb);
    		open_dialog.show ();
    	}
    
    	/* Either open the file and load the file contents or cancel. */
    	void open_response_cb (Gtk.Dialog dialog, int response_id) {
    		var open_dialog = dialog as Gtk.FileChooserDialog;
    
    		switch (response_id) {
    			case Gtk.ResponseType.ACCEPT: //open the file
    				file = open_dialog.get_file();
    
    				uint8[] file_contents;
    
    				try {
    					file.load_contents (null, out file_contents, null);
    				}
    				catch (GLib.Error err) { //handle the exception
    					error ("%s\n", err.message);
    				}
    				/* Set the buffer text to be the contents of the file. */
    				buffer.set_text ((string) file_contents,
    				                 file_contents.length);
    
    				print ("opened: %s\n", (open_dialog.get_filename ()));
    				break;
    
    			case Gtk.ResponseType.CANCEL:
    				print ("cancelled: FileChooserAction.OPEN\n");
    				break;
    		}
    		dialog.destroy ();
    	}
    
    
    	/* Create FileChooserDialog in SAVE mode. */
    	void save_as_cb (SimpleAction action, Variant? parameter) {
    		var save_dialog = new Gtk.FileChooserDialog ("Pick a file",
    		                                             this as Gtk.Window,
    		                                             Gtk.FileChooserAction.SAVE,
    		                                             Gtk.Stock.CANCEL,
    		                                             Gtk.ResponseType.CANCEL,
    		                                             Gtk.Stock.SAVE,
    		                                             Gtk.ResponseType.ACCEPT);
    
    		save_dialog.set_do_overwrite_confirmation (true);
    		save_dialog.set_modal (true);
    		if (file != null) {
    			try {
    				(save_dialog as Gtk.FileChooser).set_file (file);
    			}
    			catch (GLib.Error error) {
    				print ("%s\n", error.message);
    			}
    		}
    		save_dialog.response.connect (save_as_response_cb);
    		save_dialog.show ();
    	}
    
    	void save_as_response_cb (Gtk.Dialog dialog, int response_id) {
    		var save_dialog = dialog as Gtk.FileChooserDialog;
    
    		switch (response_id) {
    			case Gtk.ResponseType.ACCEPT:
    				file = save_dialog.get_file();
    				this.save_to_file ();
    				break;
    			default:
    				break;
    		}
    			dialog.destroy ();
    	}
    
    	/* Save the existing contents to the file.
    	 * If file does not exist, call save_as_cb.
    	 */
    	void save_cb (SimpleAction action, Variant? parameter) {
    		if (file != null) {
    			this.save_to_file ();
    		}
    		else {
    			save_as_cb (action, parameter);
    		}
    	}
    
    	void save_to_file (){
    		Gtk.TextIter start;
    		Gtk.TextIter end;
    
    		buffer.get_bounds (out start, out end);
    		string current_contents = buffer.get_text (start, end, false);
    		try {
    				file.replace_contents (current_contents.data, null, false,
    				                       GLib.FileCreateFlags.NONE, null, null);
    
    				print ("saved: %s\n", file.get_path ());
    		}
    		catch (GLib.Error err) {
    			error ("%s\n", err.message);
    		}
    	}
    }
    
    /* This is the application */
    class MyApplication: Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show_all;
    	}
    
    	const ActionEntry[] actions = {
    		{ "quit", quit_cb }
    	};
    
    	void quit_cb (SimpleAction action, Variant? parameter) {
    		this.quit ();
    	}
    
    	protected override void startup () {
    		base.startup ();
    
    		/* Setup actions */
    		this.add_action_entries (actions, this);
    
    		/* Setup menus */
    		var builder = new Gtk.Builder ();
    		try {
    			builder.add_from_file ("filechooserdialog.ui");
    		} catch (GLib.Error err) {
    			error ("Unable to load file: %s\n", err.message);
    		}
    		this.app_menu = builder.get_object ("appmenu") as MenuModel;
    	}
    }
    
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: class MyWindow: Gtk.ApplicationWindow {
    
    	/* Proměnné instance MyWindow */
    	GLib.File? file;
    	Gtk.TextBuffer buffer;
    	Gtk.TextView textview;
    	Gtk.ScrolledWindow scrolled_window;
    
    	/* Vytvoří ActionEntries. */
    	const ActionEntry[] actions = {
    		{ "new", new_cb },
    		{ "open", open_cb },
    		{ "save", save_cb },
    		{ "save-as", save_as_cb }
    	};
    
    	/* Konstruktor vytvoří MyWindow a přidá okno s posuvníky */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "FileChooserDialog Example");
    		this.set_default_size (400, 400);
    
    		/* Přidá ActionEntries do MyWindow */
    		this.add_action_entries (actions, this);
    
    		buffer = new Gtk.TextBuffer (null); // uchovává text, který se má zobrazit
    		textview = new Gtk.TextView.with_buffer (buffer); // zobrazí TextBuffer
    		textview.set_wrap_mode (Gtk.WrapMode.WORD); // nastaví zalamování řádků
    
    		scrolled_window = new Gtk.ScrolledWindow (null, null);
    		scrolled_window.set_policy (Gtk.PolicyType.AUTOMATIC,
    		                            Gtk.PolicyType.AUTOMATIC);
    
    		scrolled_window.add (textview);
    		scrolled_window.set_border_width (5);
    
            this.add (scrolled_window);
    		this.show_all ();
    	}
    
    	void new_cb (SimpleAction action, Variant? parameter) {
    		file = null;
    		buffer.set_text ("");
    		print ("New file created\n");
    	}
    
    	/* Vytvoří FileChooserDialog v režimu OPEN */
    	void open_cb (SimpleAction action, Variant? parameter) {
    
    		var open_dialog = new Gtk.FileChooserDialog ("Pick a file",
    		                                             this as Gtk.Window,
    		                                             Gtk.FileChooserAction.OPEN,
    		                                             Gtk.Stock.CANCEL,
    		                                             Gtk.ResponseType.CANCEL,
    		                                             Gtk.Stock.OPEN,
    		                                             Gtk.ResponseType.ACCEPT);
    
    		open_dialog.local_only = false; // umožní zadat URI
    		open_dialog.set_modal (true);
    		open_dialog.response.connect (open_response_cb);
    		open_dialog.show ();
    	}
    
    	/* Buď otevře a načte souboru nebo akci zruší */
    	void open_response_cb (Gtk.Dialog dialog, int response_id) {
    		var open_dialog = dialog as Gtk.FileChooserDialog;
    
    		switch (response_id) {
    			case Gtk.ResponseType.ACCEPT: // otevře soubor
    				file = open_dialog.get_file();
    
    				uint8[] file_contents;
    
    				try {
    					file.load_contents (null, out file_contents, null);
    				}
    				catch (GLib.Error err) { // obsluha výjimky
    					error ("%s\n", err.message);
    				}
    				/* Nastaví text z vyrovnávací paměti jako obsah souboru */
    				buffer.set_text ((string) file_contents,
    				                 file_contents.length);
    
    				print ("opened: %s\n", (open_dialog.get_filename ()));
    				break;
    
    			case Gtk.ResponseType.CANCEL:
    				print ("cancelled: FileChooserAction.OPEN\n");
    				break;
    		}
    		dialog.destroy ();
    	}
    
    
    	/* Vytvoří FileChooserDialog v režimu SAVE */
    	void save_as_cb (SimpleAction action, Variant? parameter) {
    		var save_dialog = new Gtk.FileChooserDialog ("Pick a file",
    		                                             this as Gtk.Window,
    		                                             Gtk.FileChooserAction.SAVE,
    		                                             Gtk.Stock.CANCEL,
    		                                             Gtk.ResponseType.CANCEL,
    		                                             Gtk.Stock.SAVE,
    		                                             Gtk.ResponseType.ACCEPT);
    
    		save_dialog.set_do_overwrite_confirmation (true);
    		save_dialog.set_modal (true);
    		if (file != null) {
    			try {
    				(save_dialog as Gtk.FileChooser).set_file (file);
    			}
    			catch (GLib.Error error) {
    				print ("%s\n", error.message);
    			}
    		}
    		save_dialog.response.connect (save_as_response_cb);
    		save_dialog.show ();
    	}
    
    	void save_as_response_cb (Gtk.Dialog dialog, int response_id) {
    		var save_dialog = dialog as Gtk.FileChooserDialog;
    
    		switch (response_id) {
    			case Gtk.ResponseType.ACCEPT:
    				file = save_dialog.get_file();
    				this.save_to_file ();
    				break;
    			default:
    				break;
    		}
    			dialog.destroy ();
    	}
    
    	/* Uloží stávající obsah do souboru
    	 * Pokud soubor neexistuje, zavolá save_as_cb
    	 */
    	void save_cb (SimpleAction action, Variant? parameter) {
    		if (file != null) {
    			this.save_to_file ();
    		}
    		else {
    			save_as_cb (action, parameter);
    		}
    	}
    
    	void save_to_file (){
    		Gtk.TextIter start;
    		Gtk.TextIter end;
    
    		buffer.get_bounds (out start, out end);
    		string current_contents = buffer.get_text (start, end, false);
    		try {
    				file.replace_contents (current_contents.data, null, false,
    				                       GLib.FileCreateFlags.NONE, null, null);
    
    				print ("saved: %s\n", file.get_path ());
    		}
    		catch (GLib.Error err) {
    			error ("%s\n", err.message);
    		}
    	}
    }
    
    /* Toto je aplikace */
    class MyApplication: Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show_all;
    	}
    
    	const ActionEntry[] actions = {
    		{ "quit", quit_cb }
    	};
    
    	void quit_cb (SimpleAction action, Variant? parameter) {
    		this.quit ();
    	}
    
    	protected override void startup () {
    		base.startup ();
    
    		/* Vytvoří akce */
    		this.add_action_entries (actions, this);
    
    		/* Vytvoří nabídky */
    		var builder = new Gtk.Builder ();
    		try {
    			builder.add_from_file ("filechooserdialog.ui");
    		} catch (GLib.Error err) {
    			error ("Unable to load file: %s\n", err.message);
    		}
    		this.app_menu = builder.get_object ("appmenu") as MenuModel;
    	}
    }
    
    /* main vytvoří a spustí aplikaci */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: section/title
en: Relevant API documentation
cs: Příslušná dokumentace k API

note: (itstool) path: info/desc
en: A widget to choose a font
cs: Widget sloužící k výběru písma

note: (itstool) path: page/p
en: A FontChooserWidget with a callback function.
cs: FontChooserWidget (výběr písma) s funkcí zpětného volání.

note: (itstool) path: section/code
en: //!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    class FontChooserWidgetExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({ application_id: 'org.example.fontchooserwidget' });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this.window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
            // Create the application window
            this.window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                        window_position: Gtk.WindowPosition.CENTER,
                                                        title: "FontChooserWidget",
                                                        default_width: 200,
                                                        default_height: 200,
                                                        border_width: 10 });
    
            this.fontChooser = new Gtk.FontChooserWidget();
            // a default font
            this.fontChooser.set_font("Sans");
            // a text to preview the font
            this.fontChooser.set_preview_text("This is an example of preview text!");
    
            // connect signal from the font chooser to the callback function
            this.fontChooser.connect("notify::font", this._fontCb.bind(this));
    
            // add the font chooser to the window
            this.window.add(this.fontChooser);
            this.window.show_all();
       }
    
         // callback function:
         _fontCb() {
            // print in the terminal
            print("You chose the font " + this.fontChooser.get_font());
        }
    };
    
    // Run the application
    let app = new FontChooserWidgetExample();
    app.application.run (ARGV);
cs: //!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    class FontChooserWidgetExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({ application_id: 'org.example.fontchooserwidget' });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this.window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
            // Vytvoří okno aplikace
            this.window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                        window_position: Gtk.WindowPosition.CENTER,
                                                        title: "FontChooserWidget",
                                                        default_width: 200,
                                                        default_height: 200,
                                                        border_width: 10 });
    
            this.fontChooser = new Gtk.FontChooserWidget();
            // Výchozí font
            this.fontChooser.set_font("Sans");
            // Text pro náhled fontu
            this.fontChooser.set_preview_text("This is an example of preview text!");
    
            // Napojí signál od výběru fontu na funkci zpětného volání
            this.fontChooser.connect("notify::font", this._fontCb.bind(this));
    
            // Přidá výběr fontu do okna
            this.window.add(this.fontChooser);
            this.window.show_all();
       }
    
         // Funkce zpětného volání
         _fontCb() {
            // Výpis do terminálu
            print("You chose the font " + this.fontChooser.get_font());
        }
    };
    
    // Spustí aplikaci
    let app = new FontChooserWidgetExample();
    app.application.run (ARGV);

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="FontChooserWidget", application=app)
    
            # a font chooser
            self.font_chooser = Gtk.FontChooserWidget()
            # a default font
            self.font_chooser.set_font("Sans")
            # a text to preview the font
            self.font_chooser.set_preview_text(
                "This is an example of preview text!")
    
            # connect signal from the font chooser to the callback function
            self.font_chooser.connect("notify::font", self.font_cb)
    
            # add the font chooser to the window
            self.add(self.font_chooser)
    
        # callback function:
        def font_cb(self, event, user_data):
            # print in the terminal
            print("You chose the font " + self.font_chooser.get_font())
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="FontChooserWidget", application=app)
    
            # Výběr písma
            self.font_chooser = Gtk.FontChooserWidget()
            # Výchozí písmo
            self.font_chooser.set_font("Sans")
            # Text pro náhled písma
            self.font_chooser.set_preview_text(
                "This is an example of preview text!")
    
            # Napojí signál od výběru písma na funkci zpětného volání
            self.font_chooser.connect("notify::font", self.font_cb)
    
            # Přidá výběr psíma do okna
            self.add(self.font_chooser)
    
        # Funkce zpětného volání
        def font_cb(self, event, user_data):
            # Vypíše do terminálu
            print("You chose the font " + self.font_chooser.get_font())
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a FontChooserWidget
cs: Užitečné metody pro FontChooserWidget

note: (itstool) path: section/p
en: In line 16 the <code>"notify::font"</code> signal from the widget is connected to the callback function <code>font_cb()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 16 je signál <code>"notify::font"</code> od widgetu napojen na funkci zpětného volání <code>font_cb()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: To set the font which is initially selected, use <code>set_font(font)</code> (where <code>font</code> is the font name) or <code>set_font_desc(font)</code> (where <code>font</code> is the PangoFontDescription).
cs: K nastavení písma, které je vybráno na počátku, použijte <code>set_font(písmo)</code> (kde <code>písmo</code> je název písma) nebo <code>set_font_desc(písmo)</code> (kde <code>písmo</code> je <code>PangoFontDescription</code>).

note: (itstool) path: item/p
en: To get the selected font use <code>get_font()</code> or <code>get_font_desc()</code>.
cs: K získání vybraného písma použijte <code>get_font()</code> nebo <code>get_font_desc()</code>.

note: (itstool) path: item/p
en: To change the text which is shown in the preview area, use <code>set_preview_text()</code>.
cs: Ke změně textu zobrazeného v oblasti s náhledem použijte <code>set_preview_text()</code>.

note: (itstool) path: page/p
en: A FontChooserWidget with a lambda callback function.
cs: FontChooserWidget s funkcí lambda zpětného volání.

note: (itstool) path: info/desc
en: A simple implementation of GMenuModel
cs: Jednoduchá implementace GMenuModel

note: (itstool) path: page/p
en: A GtkApplication with a simple GMenu and SimpleActions
cs: GtkApplication s jednoduchým widgetem GMenu a objekty SimpleAction

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class Application {
    
        //create the application
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.myapp',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
           //connect to 'activate' and 'startup' signals to the callback functions
           this.application.connect('activate', this._onActivate.bind(this));
           this.application.connect('startup', this._onStartup.bind(this));
        }
    
        //create the UI (in this case it's just the ApplicationWindow
        _buildUI() {
            this._window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                       window_position: Gtk.WindowPosition.CENTER,
                                                       title: "Welcome to GNOME" });
    
            //uncommenting the line below will change the window size
            //this._window.set_default_size(600, 400);
    
            //show the window and all child widgets (none in this case)
            this._window.show_all();
        }
    
        _showNew() {
            print("This doesn't do anything. It is only a demonstration.");
        }
    
        _showAbout() {
            print("No AboutDialog here.  This is only a demonstration.");
        }
    
        //create the menu items and connect the signals to the callback functions.
        _initMenus() {
            let menu = new Gio.Menu();
            menu.append("New",'app.new');
            menu.append("About", 'app.about');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            let newAction = new Gio.SimpleAction ({ name: 'new' });
            newAction.connect('activate', () =&gt; { this._showNew(); });
            this.application.add_action(newAction);
    
            let aboutAction = new Gio.SimpleAction ({ name: 'about' });
            aboutAction.connect('activate', () =&gt; { this._showAbout(); });
            this.application.add_action(aboutAction);
    
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
             this.application.add_action(quitAction);
        }
    
        //callback function for 'activate' signal
        _onActivate() {
            this._window.present();
        }
    
        //callback function for 'startup' signal
        _onStartup() {
            //You must call _initMenus() before calling _buildUI().
            this._initMenus();
            this._buildUI();
        }
    };
    
    //run the application
    let app = new Application ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class Application {
    
        // Vytvoří aplikaci
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.myapp',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
           // Napojí signály "activate" a "startup" k funkcím zpětného volání
           this.application.connect('activate', this._onActivate.bind(this));
           this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Vytvoří uživatelské rozhraní (v tomto případě jen ApplicationWindow)
        _buildUI() {
            this._window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                       window_position: Gtk.WindowPosition.CENTER,
                                                       title: "Welcome to GNOME" });
    
            // Zrušte zakomentování následujícího řádku, jestli chcete nastavit velikost okna
            //this._window.set_default_size(600, 400);
    
            // Zobrazí okno a všechny jeho synovské widgety (v tomto případě žádné nejsou)
            this._window.show_all();
        }
    
        _showNew() {
            print("This doesn't do anything. It is only a demonstration.");
        }
    
        _showAbout() {
            print("No AboutDialog here.  This is only a demonstration.");
        }
    
        // Vytvoří položky nabídky a napojí signály na funkce zpětného volání
        _initMenus() {
            let menu = new Gio.Menu();
            menu.append("New",'app.new');
            menu.append("About", 'app.about');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            let newAction = new Gio.SimpleAction ({ name: 'new' });
            newAction.connect('activate', () =&gt; { this._showNew(); });
            this.application.add_action(newAction);
    
            let aboutAction = new Gio.SimpleAction ({ name: 'about' });
            aboutAction.connect('activate', () =&gt; { this._showAbout(); });
            this.application.add_action(aboutAction);
    
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
             this.application.add_action(quitAction);
        }
    
        // Funkce zpětného volání pro signál "activate"
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup"
        _onStartup() {
            //You must call _initMenus() before calling _buildUI().
            this._initMenus();
            this._buildUI();
        }
    };
    
    // Spustí aplikaci
    let app = new Application ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: A simple implementation of GMenu
cs: Jednoduchá implementace GMenu.

note: (itstool) path: section/code
en: 
        from gi.repository import Gtk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="GMenu Example", application=app)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            # start the application
            Gtk.Application.do_startup(self)
    
            # create a menu
            menu = Gio.Menu()
            # append to the menu three options
            menu.append("New", "app.new")
            menu.append("About", "app.about")
            menu.append("Quit", "app.quit")
            # set the menu as menu of the application
            self.set_app_menu(menu)
    
            # create an action for the option "new" of the menu
            new_action = Gio.SimpleAction.new("new", None)
            # connect it to the callback function new_cb
            new_action.connect("activate", self.new_cb)
            # add the action to the application
            self.add_action(new_action)
    
            # option "about"
            about_action = Gio.SimpleAction.new("about", None)
            about_action.connect("activate", self.about_cb)
            self.add_action(about_action)
    
            # option "quit"
            quit_action = Gio.SimpleAction.new("quit", None)
            quit_action.connect("activate", self.quit_cb)
            self.add_action(quit_action)
    
        # callback function for "new"
        def new_cb(self, action, parameter):
            print("This does nothing. It is only a demonstration.")
    
        # callback function for "about"
        def about_cb(self, action, parameter):
            print("No AboutDialog for you. This is only a demonstration.")
    
        # callback function for "quit"
        def quit_cb(self, action, parameter):
            print("You have quit.")
            self.quit()
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: 
        from gi.repository import Gtk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="GMenu Example", application=app)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            # Spustí aplikaci
            Gtk.Application.do_startup(self)
    
            # Vytvoří nabídku
            menu = Gio.Menu()
            # Připojí do nabídky tři volby
            menu.append("New", "app.new")
            menu.append("About", "app.about")
            menu.append("Quit", "app.quit")
            # Nastaví nabídku jako aplikační nabídku
            self.set_app_menu(menu)
    
            # Vytvoří akci pro volbu "new" v nabídce
            new_action = Gio.SimpleAction.new("new", None)
            # Napojí ji na funkci zpětného volání new_cb
            new_action.connect("activate", self.new_cb)
            # Přidá akci do aplikace
            self.add_action(new_action)
    
            # Volba "about"
            about_action = Gio.SimpleAction.new("about", None)
            about_action.connect("activate", self.about_cb)
            self.add_action(about_action)
    
            # Volba "quit"
            quit_action = Gio.SimpleAction.new("quit", None)
            quit_action.connect("activate", self.quit_cb)
            self.add_action(quit_action)
    
        # Funkce zpětného volání pro "new"
        def new_cb(self, action, parameter):
            print("This does nothing. It is only a demonstration.")
    
        # Funkce zpětného volání pro "about"
        def about_cb(self, action, parameter):
            print("No AboutDialog for you. This is only a demonstration.")
    
        # Funkce zpětného volání pro "quit"
        def quit_cb(self, action, parameter):
            print("You have quit.")
            self.quit()
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a GSimpleAction and a GMenu
cs: Užitečné metody pro GSimpleAction a GMenu

note: (itstool) path: section/p
en: In line 33 the signal <code>"activate"</code> from the action <code>new_action</code> (not the menu!) is connected to the callback function <code>new_cb()</code> using <code><var>action</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 33 je signál <code>"activate"</code> od činnosti <code>new_action</code> (což není nabídka!) napojen na funkci zpětného volání <code>new_cb()</code> pomocí <code><var>action</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: section/p
en: Useful methods for a GSimpleAction:
cs: Užitečné metody pro GSimpleAction:

note: (itstool) path: item/p
en: To create a new action that is <em>stateless</em>, that is, an action that do not retain or depend on a state given by the action itself, use
cs: K vytvoření nové akce, která je <em>bezstavová</em>, což znamená, že akce neuchovává stav nebo nezávisí na stavu daném akcí samotnou, použijte:

note: (itstool) path: item/code
en: 
    action = Gio.SimpleAction.new("name", parameter_type)
cs: 
    action = Gio.SimpleAction.new("název", typ_parametru)

note: (itstool) path: item/p
en: where <code>"name"</code> is the name of the action and <code>parameter_type</code> is the type of the parameters that the action receives when being activated. This can be <code>None</code>, or <code>GLib.VariantType.new('s')</code> if the parameter is of type <code>str</code>, or instead of <code>'s'</code> a character as described <link href="http://developer.gnome.org/glib/unstable/glib-GVariantType.html">here</link>. To create a new <em>stateful</em> (i.e. not stateless) action, use
cs: kde <code>"název"</code> je název akce a <code>typ_parametru</code> je typ parametrů, která akce přijímá při aktivaci. Může to být <code>None</code> nebo <code>GLib.VariantType.new('s')</code>, když je parametr typu <code>string</code>. Místo <code>'s'</code> můžete použít i jiné znaky popsané <link href="http://developer.gnome.org/glib/unstable/glib-GVariantType.html">zde</link>. K vytvoření <em>stavové</em> akce použijte:

note: (itstool) path: item/code
en: 
    action = Gio.SimpleAction.new_stateful("name", parameter_type, initial_state)
cs: 
    action = Gio.SimpleAction.new_stateful("název", typ_parametru, počáteční_stav)

note: (itstool) path: item/p
en: where <code>initial_state</code> is defined as a GVariant - for instance <code>Glib.Variant.new_string('start')</code>; for a list of possibilities see <link href="http://developer.gnome.org/glib/unstable/glib-GVariant.html">here</link>.
cs: kde <code>počáteční_stav</code> je definován jako GVariant, například <code>Glib.Variant.new_string("start")</code>. Seznam možných stavů najdete <link href="http://developer.gnome.org/glib/unstable/glib-GVariant.html">zde</link>.

note: (itstool) path: item/p
en: <code>set_enabled(True)</code> sets the action as enabled; an action must be enabled in order to be activated or in order to have its state changed from outside callers. This should only be called by the implementor of the action. Users of the action should not attempt to modify its enabled flag.
cs: <code>set_enabled(True)</code> nastavuje akci jako povolenou. Akce musí být povolená, aby šla aktivovat nebo aby šel její stav změnit voláním zvenku. Mělo by být voláno jen implementátorem akce. Uživatel akce by neměl zkoušel měnit tento její příznak.

note: (itstool) path: item/p
en: <code>set_state(state)</code>, where <code>state</code> is a GVariant, sets the state of the action, updating the 'state' property to the given value. This should only be called by the implementor of the action; users of the action should instead call <code>change_state(state)</code> (where <code>state</code> is as above) to request the change.
cs: <code>set_state(stav)</code>, kde <code>stav</code> je GVariant, nastavuje stav akce a tím aktualizuje vlastnost <code>state</code> na zadanou hodnotu. Mělo by být voláno jen implementátorem akce. Uživatel akce by měl při požadavku na změnu místo toho volat <code>change_state(stav)</code> (kde <code>stav</code> byl zmíně v předchozím).

note: (itstool) path: section/p
en: Useful methods for a GMenu:
cs: Užitečné metody pro GMenu:

note: (itstool) path: item/p
en: To insert an item in the menu in position <code>position</code>, use <code>insert(position, label, detailed_action)</code>, where <code>label</code> is the label that will appear in the menu and <code>detailed_action</code> is a string composed of the name of the action to which we prepend the prefix <code>app.</code>. A more detailed discussion of this can be found in <link xref="menubar.py#win-app"/>.
cs: K vložení položky do nabídky na pozici <code>pozice</code> použijte <code>insert(pozice, popisek, upřesnění_akce)</code>, kde <code>popisek</code> je text, který se v nabídce objeví a <code>upřesnění_akce</code> je složený řetězec v podobě názvu akce, před který se připojí předpona <code>app.</code>. Podrobnější rozebrání této záležitosti můžete najít v <link xref="menubar.py#win-app"/>.

note: (itstool) path: item/p
en: To append or prepend an item in the menu use respectively <code>append(label, detailed_action)</code> and <code>prepend(label, detailed_action)</code>.
cs: Pro připojení položky do nabídky na konec respektive na začátek použijte <code>append(popisek, upřesnění_akce)</code> respektive <code>prepend(popisek, upřesnění_akce)</code>.

note: (itstool) path: item/p
en: Another way of adding items to the menu is to create them as <code>GMenuItem</code>s and use <code>insert_item(position, item)</code>, <code>append_item(item)</code>, or <code>prepend_item(item)</code>; so for instance we might have:
cs: Jiným způsobem, jak přidat položky do nabídky, je vytvořit je jako widgety <code>GMenuItem</code> a použít <code>insert_item(pozice, položka)</code>, <code>append_item(položka)</code> nebo <code>prepend_item(položka)</code>. Takže například můžeme mít:

note: (itstool) path: item/p
en: We can also add a whole subsection in a menu using <code>insert_section(position, label, section)</code>, <code>append_section(label, section)</code>, or <code>prepend_section(label, section)</code>, where <code>label</code> is the title of the subsection.
cs: Do nabídky můžeme také přidat celý pododdíl pomocí <code>insert_section(pozice, popisek, oddíl)</code>, <code>append_section(popisek, oddíl)</code> nebo <code>prepend_section(popisek, oddíl)</code>, kde <code>popisek</code> je název pododdílu.

note: (itstool) path: item/p
en: To add a submenu that will expand and collapse, use <code>insert_submenu(position, label, section)</code>, <code>append_submenu(label, section)</code>, or <code>prepend_submenu(label, section)</code>, where <code>label</code> is the title of the subsection.
cs: Přidáme také celou podnabídku, která se bude rozbalovat a sbalovat, pomocí <code>insert_submenu(pozice, popisek, oddíl)</code>, <code>append_submenu(popisek, oddíl)</code> nebo <code>prepend_submenu(popisek, oddíl)</code>, kde <code>popisek</code> jen název pododdílu.

note: (itstool) path: item/p
en: To remove an item from the menu, use <code>remove(position)</code>.
cs: K odstranění položky z nabídky použijte <code>remove(pozice)</code>.

note: (itstool) path: item/p
en: To set a label for the menu, use <code>set_label(label)</code>.
cs: K nastavení popisku pro nabídku použijte <code>set_label(popisek)</code>.

note: (itstool) path: note/p
en: <em style="strong">You need to be running GTK+-3.4 or later for this to work</em>
cs: <em style="strong">Musíte používat GTK+ 3.4 nebo novější, aby tento příklad fungoval.</em>

note: (itstool) path: page/code
en: /* A window in the application. */
    public class Window : Gtk.ApplicationWindow {
    
    	/* Constructor */
    	public Window (Application app) {
    		Object (application: app, title: "Gmenu Example");
    
    		var about_action = new SimpleAction ("about", null);
    
    		/* Connect the 'activate' signal to the
    		 * signal handler (aka. callback).
    		 */
    		about_action.activate.connect (this.about_cb);
    
    		/* Add the action to this window. */
    		this.add_action (about_action);
    
    		this.show ();
    	}
    
    	/* Signal handler for 'activate' signal of the SimpleAction. */
    	void about_cb (SimpleAction simple, Variant? parameter) {
    		print ("This does nothing.  It is only a demonstration.\n");
    	}
    }
    
    /* This is the Application. */
    public class Application : Gtk.Application {
    
    	/* Constructor */
    	public Application () {
    		Object (application_id: "org.example.application");
    	}
    
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    
    		/* Create a new window for this application. */
    		new Window (this);
    	}
    
    	/* Override the 'startup' signal of GLib.Application. */
    	protected override void startup () {
    		base.startup ();
    
    		var menu = new Menu ();
    		menu.append ("About", "win.about");
    		menu.append ("Quit", "app.quit");
    		this.app_menu = menu;
    
    		var quit_action = new SimpleAction ("quit", null);
    		quit_action.activate.connect (this.quit);
    		this.add_action (quit_action);
    	}
    }
    
    /* main function creates Application and runs it. */
    int main (string[] args) {
    	return new Application ().run (args);
    }
cs: /* Okno v aplikaci */
    public class Window : Gtk.ApplicationWindow {
    
    	/* Konstruktor */
    	public Window (Application app) {
    		Object (application: app, title: "Gmenu Example");
    
    		var about_action = new SimpleAction ("about", null);
    
    		/* Napojí signál "activate" na obsluhu 
    		 * signálu (neboli funkci zpětného volání)
    		 */
    		about_action.activate.connect (this.about_cb);
    
    		/* Přidá akci do tohoto okna */
    		this.add_action (about_action);
    
    		this.show ();
    	}
    
    	/* Zpracování signálu pro signál "activate"' od SimpleAction */
    	void about_cb (SimpleAction simple, Variant? parameter) {
    		print ("This does nothing.  It is only a demonstration.\n");
    	}
    }
    
    /* Toto je aplikace */
    public class Application : Gtk.Application {
    
    	/* Konstruktor */
    	public Application () {
    		Object (application_id: "org.example.application");
    	}
    
    	/* Přepíše signál "activate" z GLib.Application */
    	protected override void activate () {
    
    		/* Vytvoří nové okno pro tuto aplikaci */
    		new Window (this);
    	}
    
    	/* Přepíše signál "startup" z GLib.Application */
    	protected override void startup () {
    		base.startup ();
    
    		var menu = new Menu ();
    		menu.append ("About", "win.about");
    		menu.append ("Quit", "app.quit");
    		this.app_menu = menu;
    
    		var quit_action = new SimpleAction ("quit", null);
    		quit_action.activate.connect (this.quit);
    		this.add_action (quit_action);
    	}
    }
    
    /* Funkce main vytvoří aplikaci a spustí ji */
    int main (string[] args) {
    	return new Application ().run (args);
    }

note: (itstool) path: info/desc
en: Pack widgets in rows and columns
cs: Balí widgety do řádků a sloupců

note: (itstool) path: page/p
en: A button widget connected to a progress bar.
cs: Widget tlačítka napojený na ukazatel průběhu.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /*Signal handler for the "clicked" signal of the Button. Each
    click generates a progress bar pulse*/
    static void
    on_button_click (GtkButton *button,
                     gpointer   user_data)
    {
      GtkProgressBar *progress_bar = user_data;
      gtk_progress_bar_pulse (progress_bar);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *grid;
      GtkWidget *window;
      GtkWidget *button;
      GtkWidget *progress_bar;
    
      /*Create the window and set a title*/
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Grid Example");
    
      /*Create a button with a label*/
      button = gtk_button_new_with_label ("Button");
    
      /*Create the progress bar*/
      progress_bar = gtk_progress_bar_new ();
    
      /*Create a grid and attach the button and progress bar
      accordingly*/
      grid = gtk_grid_new ();
      gtk_grid_attach (GTK_GRID (grid), button, 1, 1, 1, 1);
      gtk_grid_attach_next_to (GTK_GRID (grid), 
                               progress_bar, 
                               button, 
                               GTK_POS_BOTTOM, 1, 1);
    
      /*Connecting the clicked signal to the callback function*/
      g_signal_connect (GTK_BUTTON (button), "clicked", 
                        G_CALLBACK (on_button_click), progress_bar);
    
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Obsluha signálu pro signál "clicked" tlačítka. Každé 
       kliknutí vygeneruje zapulzování ukazatele průběhu */
    static void
    on_button_click (GtkButton *button,
                     gpointer   user_data)
    {
      GtkProgressBar *progress_bar = user_data;
      gtk_progress_bar_pulse (progress_bar);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *grid;
      GtkWidget *window;
      GtkWidget *button;
      GtkWidget *progress_bar;
    
      /* Vytvoří okno a nastaví mu název */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Grid Example");
    
      /* Vytvoří tlačítko s popiskem */
      button = gtk_button_new_with_label ("Button");
    
      /* Vytvoří ukazatel průběhu */
      progress_bar = gtk_progress_bar_new ();
    
      /* Vytvoří mřížku a správně do ní připojí tlačítko a ukazatel
         průběhu */
      grid = gtk_grid_new ();
      gtk_grid_attach (GTK_GRID (grid), button, 1, 1, 1, 1);
      gtk_grid_attach_next_to (GTK_GRID (grid), 
                               progress_bar, 
                               button, 
                               GTK_POS_BOTTOM, 1, 1);
    
      /* Napojí signál "clicked" na funkci zpětného volání */
      g_signal_connect (GTK_BUTTON (button), "clicked", 
                        G_CALLBACK (on_button_click), progress_bar);
    
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: page/p
en: A button widget connected to a progress bar, inside of a grid which handles the layout.
cs: Widget tlačítka spojený s ukazatelem průběhu, uvnitř mřížky, která se stará o rozvržení.

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class GridExample {
    
        /* Create the application itself
           This boilerplate code is needed to build any GTK+ application. */
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jsgrid',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal initializes menus and builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
                this._window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                             window_position: Gtk.WindowPosition.CENTER,
                                                             title: "Grid Example"});
    
            // Create the grid
            this.Grid = new Gtk.Grid ();
    
            // Create the widgets inside the grid
            this.progressBar = new Gtk.ProgressBar ();
            this.Button = new Gtk.Button ({ label: "Button" });
            this.Button.connect ("clicked", this._clickHandler.bind(this));
    
            // Assemble the grid
            this._window.add (this.Grid);
            this.Grid.attach (this.Button, 1, 1, 1, 1);
            this.Grid.attach_next_to (this.progressBar, this.Button, Gtk.PositionType.BOTTOM, 1, 1);
    
                    // Show the window and all child widgets
                    this._window.show_all();
        }
    
        // Here's the function that says what happens when the button is clicked
        _clickHandler() {
            this.progressBar.pulse ();
        }
    
    
    };
    
    // Run the application
    let app = new GridExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class GridExample {
    
        /* Vytvoří vlastní aplikaci
           This boilerplate code is needed to build any GTK+ application. */
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jsgrid',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
                this._window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                             window_position: Gtk.WindowPosition.CENTER,
                                                             title: "Grid Example"});
    
            // Vytvoří mřížku
            this.Grid = new Gtk.Grid ();
    
            // Vytvoří widgety v mřížce
            this.progressBar = new Gtk.ProgressBar ();
            this.Button = new Gtk.Button ({ label: "Button" });
            this.Button.connect ("clicked", this._clickHandler.bind(this));
    
            // Sestaví mřížku
            this._window.add (this.Grid);
            this.Grid.attach (this.Button, 1, 1, 1, 1);
            this.Grid.attach_next_to (this.progressBar, this.Button, Gtk.PositionType.BOTTOM, 1, 1);
    
                    // Zobrazí okno a všechny jeho synovské widgety
                    this._window.show_all();
        }
    
        // Zde je funkce, která říká, co se stane, když je na tlačítko kliknuto
        _clickHandler() {
            this.progressBar.pulse ();
        }
    
    
    };
    
    // Spustí aplikaci
    let app = new GridExample ();
    app.application.run (ARGV);

note: (itstool) path: page/p
en: Some labels in a grid.
cs: Pár popisků v mřížce.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Grid Example", application=app)
    
            # three labels
            label_top_left = Gtk.Label(label="This is Top Left")
            label_top_right = Gtk.Label(label="This is Top Right")
            label_bottom = Gtk.Label(label="This is Bottom")
    
            # a grid
            grid = Gtk.Grid()
    
            # some space between the columns of the grid
            grid.set_column_spacing(20)
    
            # in the grid:
            # attach the first label in the top left corner
            grid.attach(label_top_left, 0, 0, 1, 1)
            # attach the second label
            grid.attach(label_top_right, 1, 0, 1, 1)
            # attach the third label below the first label
            grid.attach_next_to(
                label_bottom, label_top_left, Gtk.PositionType.BOTTOM, 2, 1)
    
            # add the grid to the window
            self.add(grid)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Grid Example", application=app)
    
            # Tři popisky
            label_top_left = Gtk.Label(label="This is Top Left")
            label_top_right = Gtk.Label(label="This is Top Right")
            label_bottom = Gtk.Label(label="This is Bottom")
    
            # Mřížka
            grid = Gtk.Grid()
    
            # Nějaké místo mezi sloupci v mřížce
            grid.set_column_spacing(20)
    
            # V mřížce:
            # Připojíme první popisek do levého horního rohu
            grid.attach(label_top_left, 0, 0, 1, 1)
            # Připojíme druhý popisek
            grid.attach(label_top_right, 1, 0, 1, 1)
            # Připojíme třetí popisek pod první popisek
            grid.attach_next_to(
                label_bottom, label_top_left, Gtk.PositionType.BOTTOM, 2, 1)
    
            # Přidá mřížku do okna
            self.add(grid)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Grid widget
cs: Užitečné metody pro widget Grid

note: (itstool) path: item/p
en: To attach a widget <code>child</code> in position <code>left, top</code> in a slot of given <code>width, height</code> use <code>attach(child, top, left, width, height)</code>. If a widget <code>sibling</code> is already in place, we can also use <code>attach_next_to(child, sibling, side, width, height)</code>, where <code>side</code> is one of <code>Gtk.PositionType.LEFT, Gtk.PositionType.RIGHT, Gtk.PositionType.TOP, Gtk.PositionType.BOTTOM</code>.
cs: Pro připojení widgetu <code>potomek</code> na pozici <code>zleva, shora</code> s danou <code>šířkou, výškou</code> použijte <code>attach(potomek, shora, zleva, šířka, výška)</code>. Pokud je již umístěn widget <code>sourozenec</code>, můžeme použít také <code>attach_next_to(potomek, sourozenec, strana, šířka, výška)</code>, kde <code>strana</code> je jedno z <code>Gtk.PositionType.LEFT</code>, <code>Gtk.PositionType.RIGHT</code>, <code>Gtk.PositionType.TOP</code>, <code>Gtk.PositionType.BOTTOM</code>.

note: (itstool) path: item/p
en: <code>insert_row(position)</code> and <code>insert_column(position)</code> do exactly what they say; children which are attached at or below this position are moved one row down, and children which span across this position are grown to span the new row. <code>insert_next_to(sibling, side)</code> inserts a row or column at the specified position. The new row or column is placed next to <code>sibling</code>, on the side determined by <code>side</code>; if side is <code>Gtk.PositionType.TOP</code> or <code>Gtk.PositionType.BOTTOM</code>, a row is inserted, if side is <code>Gtk.PositionType.LEFT</code> or <code>Gtk.PositionType.RIGHT</code>, a column is inserted.
cs: <code>insert_row(pozice)</code> a <code>insert_column(pozice)</code> vkládají řádek respektive sloupec. Potomci, kteří jsou na této pozici nebo pod ní jsou posunuti o řádek níž a potomci roztažní přes tuto pozici se roztáhnou i přes nový řádek. <code>insert_next_to(sourozenec, strana)</code> vloží řádek nebo sloupec na zadanou pozici. Nový řádek nebo sloupec je umístěn vedle <code>sourozence</code> na straně určené argumentem <code>strana</code>. Pokud <code>strana</code> je <code>Gtk.PositionType.TOP</code> nebo <code>Gtk.PositionType.BOTTOM</code>, je vložen řádek, pokud <code>Gtk.PositionType.LEFT</code> nebo <code>Gtk.PositionType.RIGHT</code>, je vložen sloupec.

note: (itstool) path: item/p
en: <code>set_row_homogeneous(True)</code> and <code>set_column_homogeneous(True)</code> ensure that (respectively) every row or every column has the same width or height.
cs: <code>set_row_homogeneous(True)</code> a <code>set_column_homogeneous(True)</code> zajistí, že každý řádek respektive sloupec bude mít stejnou výšku respektive šířku.

note: (itstool) path: item/p
en: <code>set_row_spacing(spacing)</code> and <code>set_column_spacing(spacing)</code> force a spacing between (respectively) rows or columns. The value of <code>spacing</code> can be between <code>0</code>, which is the default value, and <code>32767</code>.
cs: <code>set_row_spacing(rozestup)</code> a <code>set_column_spacing(rozestup)</code> vynutí rozestup mezi řádky respektive sloupci. Hodnota <code>rozestup</code> může být mezi <code>0</code>, což je výchozí hodnota, a <code>32767</code>.

note: (itstool) path: page/title
en: Grid widget
cs: Widget Grid

note: (itstool) path: info/desc
en: A toplevel window which can contain other widgets, and support GMenu
cs: Okno nejvyšší úrovně, které může obsahovat ostatní widgety a podporuje GMenu.

note: (itstool) path: page/p
en: A minimal GtkApplication with a GtkApplicationWindow
cs: Nejjednodušší GtkApplication s GtkApplicationWindow.

note: (itstool) path: info/desc
en: GtkWindow subclass with GtkApplication support
cs: Podtřída GtkWindow s podporou GtkApplication

note: (itstool) path: page/p
en: A simple GtkApplicationWindow which can support Menus.
cs: Nejjednodušší GtkApplicationWindow, které umí podporovat nabídky.

note: (itstool) path: page/code
en: 
    #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class Application {
    
        //create the application
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.myapp',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
           //connect to 'activate' and 'startup' signals to the callback functions
           this.application.connect('activate', this._onActivate.bind(this));
           this.application.connect('startup', this._onStartup.bind(this));
        }
    
        //create the UI (in this case it's just the ApplicationWindow
        _buildUI() {
            this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                       window_position: Gtk.WindowPosition.CENTER,
                                                       title: "Welcome to GNOME" });
    
            //uncommenting the line below will change the window size
            //this._window.set_default_size(600, 400);
    
            //show the window and all child widgets (none in this case)
            this._window.show_all();
        }
    
        //callback function for 'activate' signal
        _onActivate() {
            this._window.present();
        }
    
        //callback function for 'startup' signal
        _onStartup() {
            this._buildUI();
        }
    };
    
    //run the application
    let app = new Application ();
    app.application.run (ARGV);
cs: 
    #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class Application {
    
        // Vytvoří aplikaci
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.myapp',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
           // Napojí signály "activate" a "startup" k funkcím zpětného volání
           this.application.connect('activate', this._onActivate.bind(this));
           this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Vytvoří uživatelské rozhraní (v tomto případě jen ApplicationWindow)
        _buildUI() {
            this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                       window_position: Gtk.WindowPosition.CENTER,
                                                       title: "Welcome to GNOME" });
    
            // Zrušte zakomentování následujícího řádku, jestli chcete nastavit velikost okna
            //this._window.set_default_size(600, 400);
    
            // Zobrazí okno a všechny jeho synovské widgety (v tomto případě žádné nejsou)
            this._window.show_all();
        }
    
        // Funkce zpětného volání pro signál "activate"
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup"
        _onStartup() {
            this._buildUI();
        }
    };
    
    // Spustí aplikaci
    let app = new Application ();
    app.application.run (ARGV);

note: (itstool) path: page/p
en: The simplest GtkApplication Window which can support <link xref="gmenu.py"/>.
cs: Nejjednodušší okno GtkApplication, které umí podporovat <link xref="gmenu.py"/>.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    # a Gtk ApplicationWindow
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # constructor: the title is "Welcome to GNOME" and the window belongs
        # to the application app
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
    
    
    class MyApplication(Gtk.Application):
        # constructor of the Gtk Application
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        # create and activate a MyWindow, with self (the MyApplication) as
        # application the window belongs to.
        # Note that the function in C activate() becomes do_activate() in Python
        def do_activate(self):
            win = MyWindow(self)
            # show the window and all its content
            # this line could go in the constructor of MyWindow as well
            win.show_all()
    
        # start up the application
        # Note that the function in C startup() becomes do_startup() in Python
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    # create and run the application, exit with the value returned by
    # running the program
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    # Gtk ApplicationWindow
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # Konstruktor: název je "Welcome to GNOME" a okno náleží
        # aplikaci app
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
    
    
    class MyApplication(Gtk.Application):
        # Konstruktor Gtk Application
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        # Vytvoří a aktivuje MyWindow, se self (MyApplication) jako aplikací, 
        # ke které okno patří.
        # Všimněte si, že funkce activate() v jazyce C se změní na do_activate()
        # v jazyce Python
        def do_activate(self):
            win = MyWindow(self)
            # Zobrazí okno a veškerý jeho obsah
            # Tento řádek by mohl být stejně dobře v konstruktoru MyWindow
            win.show_all()
    
        # Spustí aplikaci
        # Všimněte si, že funkce starup() v jazyce C se změní na do_startup()
        # v jazyce Python
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    # Vytvoří a spustí aplikaci; skončí s hodnotou vrácenou běžícím programem
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Gtk.ApplicationWindow widget
cs: Užitečné metody widgetu Gtk.ApplicationWindow

note: (itstool) path: item/p
en: <code>set_default_size(200, 100)</code> sets the default size of the window to a width of <code>200</code> and a height of <code>100</code>; if instead of a positive number we pass <code>-1</code> we have the default size.
cs: <code>set_default_size(200, 100)</code> nastaví výchozí velikost okna na šířku <code>200</code> a výšku <code>100</code>. Když místo kladného čísla předáte <code>-1</code> dostanete výchozí velikost.

note: (itstool) path: item/p
en: <code>set_position(Gtk.WindowPosition.CENTER)</code> centers the window. Other options are <code>Gtk.WindowPosition.NONE, Gtk.WindowPosition.MOUSE, Gtk.WindowPosition.CENTER_ALWAYS, Gtk.WindowPosition.CENTER_ON_PARENT</code>.
cs: <code>set_position(Gtk.WindowPosition.CENTER)</code> umístí okno na střed. Další možnosti jsou <code>Gtk.WindowPosition.NONE</code> (neurčeno), <code>Gtk.WindowPosition.MOUSE</code> (pozice ukazatele myši), <code>Gtk.WindowPosition.CENTER_ALWAYS</code> (vždy na střed) a <code>Gtk.WindowPosition.CENTER_ON_PARENT</code> (na střed rodiče).

note: (itstool) path: page/p
en: The simplest GtkApplication Window which can support Menus.
cs: Nejjednodušší okno GtkApplication, které umí podporovat nabídky.

note: (itstool) path: page/code
en: 
    /* This is the application. */
    public class MyApplication : Gtk.Application {
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    		/* Create the window of this application and show it. */
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "Welcome to GNOME";
    		window.show ();
    	}
    }
    
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: 
    /* Toto je aplikace */
    public class MyApplication : Gtk.Application {
    	/* Přepíše signál 'activate' z GLib.Application. */
    	protected override void activate () {
    		/* Vytvoří okno této aplikace a zobrazí jej. */
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "Welcome to GNOME";
    		window.show ();
    	}
    }
    
    /* main vytvoří a spustí aplikaci */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

[ctx: text]
note: (itstool) path: info/title
en: Guitar tuner (C)
cs: Kytarová ladička (C)

note: (itstool) path: info/desc
en: Use GTK+ and GStreamer to build a simple guitar tuner application for GNOME. Shows off how to use the interface designer.
cs: Jak použít GTK+ a GStreamer k sestavení jednoduché aplikace pro GNOME fungující jako kytarová ladička. Předvedeme si, jako používat návrhář rozhraní.

note: (itstool) path: page/title
en: Guitar tuner
cs: Kytarová ladička

note: (itstool) path: synopsis/p
en: In this tutorial, we're going to make a program which plays tones that you can use to tune a guitar. You will learn how to:
cs: V této lekci vytvoříme program, který přehrává tóny, které můžete použít k ladění kytary. Naučíte se, jak udělat tyto věci:

note: (itstool) path: item/p
en: Set up a basic project in Anjuta
cs: Vytvořit základní projekt ve studiu Anjuta.

note: (itstool) path: item/p
en: Create a simple GUI with Anjuta's UI designer
cs: Vytvořit jednoduché GUI v návrháři GUI ve studiu Anjuta.

note: (itstool) path: item/p
en: Use GStreamer to play sounds
cs: Použít GStreamer k přehrání zvuku.

note: (itstool) path: synopsis/p
en: You'll need the following to be able to follow this tutorial:
cs: Abyste mohli pokračovat v této lekci, budete potřebovat následující:

note: (itstool) path: item/p
en: An installed copy of the <link xref="getting-ready">Anjuta IDE</link>
cs: Nainstalovanou kopii <link xref="getting-ready">IDE Anjuta</link>

note: (itstool) path: item/p
en: Basic knowledge of the C programming language
cs: Základní znalosti programovacího jazyka C

note: (itstool) path: section/title
en: Create a project in Anjuta
cs: Vytvoření projektu ve studiu Anjuta

note: (itstool) path: section/p
en: Before you start coding, you'll need to set up a new project in Anjuta. This will create all of the files you need to build and run the code later on. It's also useful for keeping everything together.
cs: Než začnete s kódováním, musíte ve studiu Anjuta vytvořit nový projekt. Tím se vytvoří všechny soubory, které budete později potřebovat k sestavení a spuštění kódu. Je to také užitečné kvůli udržení všeho pohromadě.

note: (itstool) path: item/p
en: Start Anjuta and click <guiseq><gui>File</gui><gui>New</gui><gui>Project</gui></guiseq> to open the project wizard.
cs: Spusťte IDE Anjuta a klikněte na <guiseq><gui>Soubor</gui> <gui>Nový</gui> <gui>Projekt</gui></guiseq>, aby se otevřel průvodce projektem.

note: (itstool) path: item/p
en: Choose <gui>GTK+ (Simple)</gui> from the <gui>C</gui> tab, click <gui>Continue</gui>, and fill out your details on the next few pages. Use <file>guitar-tuner</file> as project name and directory.
cs: Na kartě <gui>C</gui> zvolte <gui>GTK+ (jednoduchý)</gui>, klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>guitar-tuner</file>.

note: (itstool) path: item/p
en: Make sure that <gui>Configure external packages</gui> is switched <gui>ON</gui>. On the next page, select <em>gstreamer-0.10</em> from the list to include the GStreamer library in your project.
cs: Ujistěte se, že <gui>Konfigurovat externí balíčky</gui> je přepnuto na <gui>Zapnuto</gui>. Na následující stránce vyberte v seznamu <em>gstreamer-0.10</em>, aby se knihovna GStreamer zahrnula do vašeho projektu.

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. Open <file>src/main.c</file> from the <gui>Project</gui> or <gui>File</gui> tabs. You should see some code which starts with the lines:
cs: Klikněte na <gui>Použít</gui> a vytvoří se vám projekt. Otevřete <file>src/main.c</file> na kartě <gui>Projekt</gui> nebo <gui>Soubor</gui>. Měli byste vidět kód, který začíná řádky:

note: (itstool) path: section/title
en: Build the code for the first time
cs: Prvotní sestavení kódu

note: (itstool) path: section/p
en: 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:
cs: C je celkem „upovídaný“ jazyk, takže nebuďte překvapeni, že soubor obsahuje poměrně hodně kódu. Většina toho je kód šablony. Načte (prázdné) okno ze souboru s popisem uživatelského rozhraní a zobrazí jej. Dále to podrobněji rozebereme. Pokud jste již pochopili základy, tak tento seznam můžete přeskočit:

note: (itstool) path: item/p
en: 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.
cs: Tři řádky <code>#include</code> na začátku vkládají knihovny <code>config</code> (užitečné definice pro sestavení pomocí autotools), <code>gtk</code> (uživatelské rozhraní) a <code>gi18n</code> (internacionalizace). Funkce z těchto knihoven se používají ve zbytku kódu.

note: (itstool) path: item/p
en: 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.
cs: Funkce <code>create_window</code> vytvoří nové okno ze souboru GtkBulder (<file>src/guitar-tuner.ui</file>, definováno o pár řádků výše), připojí jeho signály a zobrazí jej v okně. Soubor GtkBuilder obsahuje popis uživatelského rozhraní a jeho prvků. K návrhu uživatelského rozhraní GtkBuilder můžete použít editor přímo ve vývojářském studiu Anjuta.

note: (itstool) path: item/p
en: 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.
cs: Napojení signálu je způsob, jak definovat, co se má stát, když zmáčknete tlačítko nebo se prostě něco přihodí. Zde je zavolána metoda <code>destroy</code> (a ukončení aplikace) při zavření okna.

note: (itstool) path: item/p
en: 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).
cs: Funkce <code>main</code> se spustí jako výchozí, když spustíte aplikaci napsanou v jazyce C. Volá pár funkcí, které nastaví a spustí aplikaci. Funkce <code>gtk_main</code> spustí hlavní smyčku GTK, která spustí uživatelské rozhraní a začne naslouchat událostem (jako je kliknutí nebo zmáčknutí klávesy).

note: (itstool) path: item/p
en: 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.
cs: Podmíněná definice <code>ENABLE_NLS</code> nastavuje <code>gettext</code>, což je základní konstrukce pro překládání aplikací do národních jazyků. Tyto funkce určují, jak mají překladové nástroje pracovat s vaší aplikací za běhu.

note: (itstool) path: section/p
en: 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>).
cs: Kód je připravený k použití, takže jej můžete zkompilovat kliknutím na <guiseq><gui>Sestavit</gui> <gui>Sestavit projekt</gui></guiseq> (nebo zmáčknutím <keyseq><key>Shift</key> <key>F7</key></keyseq>).

note: (itstool) path: section/p
en: Press <gui>Execute</gui> on the next window that appears to configure a debug build. You only need to do this once, for the first build.
cs: V následujícím okně zmáčkněte <gui>Spustit</gui>, aby se nakonfigurovalo ladicí sestavení. Stačí to udělat jen jednou, pro první sestavení.

note: (itstool) path: section/title
en: Create the user interface
cs: Vytvoření uživatelského rozhraní

note: (itstool) path: section/p
en: 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.
cs: Popis uživatelského rozhraní se nachází v souboru GtkBuilder. Když chcete uživatelské rozhraní upravit, otevřete <file>src/guitar_tuner.ui</file>. Přepnete se tím do návrháře rozhraní. Navrhované okno je uprostřed, widgety a jejich vlastnosti jsou nalevo a paleta dostupných widgetů je napravo.

note: (itstool) path: section/p
en: 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.
cs: Rozvržení každého uživatelského rozhraní v GTK+ je provedeno pomocí boxů a mřížek. Zde použijeme svislý <code>GtkButtonBox</code>, do kterého přiřadíme šest <code>GtkButtons</code>, jedno pro každou z kytarových strun.

note: (itstool) path: item/p
en: 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.
cs: Vyberte <gui>GtkButtonBox</gui> z oddílu <gui>Kontejnery</gui> v <gui>Paletě</gui> napravo a vložte jej do okna. V panelu <gui>Vlastnosti</gui> nastavte počet prvků na 6 (pro 6 strun) a orientaci na svislou.

note: (itstool) path: item/p
en: Now, choose a <gui>GtkButton</gui> from the palette and put it into the first part of the box.
cs: Nyní v paletě zvolte <gui>GtkButton</gui> a vložte jej do první části boxu.

note: (itstool) path: item/p
en: 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.
cs: Zatímco je tlačítko stále vybráno, změňte vlastnost <gui>Popisek</gui> na kartě <gui>Widgety</gui> na <gui>E</gui>. Bude se jednat o spodní strunu E.

note: (itstool) path: item/p
en: 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>.
cs: Přepněte se na kartu <gui>Signál</gui> (uvnitř karty <gui>Widgety</gui>) a podívejte se po signálu <code>clicked</code> tlačítka. Můžete jej použít k napojení na obsluhu signálu, která bude volána, když uživatel na tlačítko klikne. Provede se to kliknutím na signál a vepsáním <code>on_button_clicked</code> do sloupce <gui>Obslužná rutina</gui> a zmáčknutím <key>Enter</key>.

note: (itstool) path: item/p
en: Repeat the above steps for the other buttons, adding the next 5 strings with the names <em>A</em>, <em>D</em>, <em>G</em>, <em>B</em>, and <em>e</em>.
cs: Zopakujte předchozí kroky pro ostatní tlačítka, takže přidáte následujících 5 strun s názvy <em>A</em>, <em>D</em>, <em>G</em>, <em>B</em> a <em>e</em>.

note: (itstool) path: item/p
en: Save the UI design (by clicking <guiseq><gui>File</gui><gui>Save</gui></guiseq>) and keep it open.
cs: Návrh uživatelského rozhraní uložte (kliknutím na <guiseq><gui>Soubor</gui> <gui>Uložit</gui></guiseq>) a ponechte jej otevřený.

note: (itstool) path: section/title
en: Creating the signal handler
cs: Vytvoření obsluhy signálů

note: (itstool) path: section/p
en: 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.
cs: V návrháři uživatelského rozhraní můžete nastavit to, že všechna tlačítka budou při kliknutí volat stejnou funkci <gui>on_button_clicked</gui>. Tuto funkci musíme přidat do zdrojového kódu.

note: (itstool) path: section/p
en: 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:
cs: K tomu otevřete <file>main.c</file> a soubor s uživatelským rozhraním při tom ponechte stále otevřený. Přepněte se na kartu <gui>Signály</gui>, kterou jste již použili pro nastavení názvu signálu. Nyní chytněte řádek, na kterém jste nastavili signál <gui>clicked</gui> a přetáhněte jej do zdrojového kódu na místo mimo kteroukoliv funkci. Do zdrojového kódu se přidá následující kód:

note: (itstool) path: section/p
en: 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.)
cs: Obsluha signálu má dva argumenty: ukazatel na <code>GtkWidget</code>, který funkci zavolal (v našem případě vždy <code>GtkButton</code>) a ukazatel na nějaká „uživatelská data“, která si můžete nadefinovat, ale zde je nebudeme chtít použít. (Uživatelská data můžete nastavit zavoláním <code>gtk_builder_connect_signals</code>. Normálně se použivá k předání ukazatele na datovou strukturu, ke které můžete potřebovat přístup uvnitř obsluhy signálu.)

note: (itstool) path: section/p
en: For now, we'll leave the signal handler empty while we work on writing the code to produce sounds.
cs: Prozatím ponecháme obsluhu signálu prázdnou a budeme pracovat na psaní kódu pro vyluzování zvuků.

note: (itstool) path: section/title
en: GStreamer pipelines
cs: Roury systému GStreamer

note: (itstool) path: section/p
en: GStreamer is GNOME's multimedia framework — you can use it for playing, recording, and processing video, audio, webcam streams and the like. Here, we'll be using it to produce single-frequency tones.
cs: GStreamer je základní multimediální rámec GNOME. Můžete jej použít k přehrávání, nahrávání a zpracování videa, zvuku, vysílání z webové kamery a podobně. Zde jej použijeme ke generování tónu s jednou frekvencí.

note: (itstool) path: section/p
en: 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.
cs: Koncepčně GStreamer funguje následovně: Vytvoříte <em>rouru</em> (pipeline) obsahující různé prvky zpracující směrem od <em>zdroje</em> (source) do <em>cíle</em> (sink), tj. výstupu. Zdrojem může být například soubor s obrázkem, videosoubor nebo hudební soubor, výstupem pak widget nebo zvuková karta.

note: (itstool) path: section/p
en: 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.
cs: Na cestě mezi zdrojem a cílem můžete použít různé filtry a převodníky k vytvoření efektů, převodníky formátů atd. Každý prvek roury má vlastnosti, které můžete použít ke změně jeho chování.

note: (itstool) path: media/p
en: An example GStreamer pipeline.
cs: Příklad roury systému GStreamer.

note: (itstool) path: section/title
en: Set up the pipeline
cs: Vytvoření roury

note: (itstool) path: section/p
en: 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>.
cs: V tomto příkladu použijeme jako zdroj tónový generátor nazývaný <code>audiotestsrc</code> a výstup pošleme do výchozího systémového zvukového zařízení <code>autoaudiosink</code>. Nastavit potřebujeme jen frekvenci tónového generátoru. Ta je přístupná přes vlastnost <code>freq</code> zmíněného <code>audiotestsrc</code>.

note: (itstool) path: section/p
en: Insert the following line into <file>main.c</file>, just below the <code>#include &lt;gtk/gtk.h&gt;</code> line:
cs: Vložte do <file>main.c</file> následující řádek, hned pod řádek <code>#include &lt;gtk/gtk.h&gt;</code>:

note: (itstool) path: section/p
en: This includes the GStreamer library. You also need to add a line to initialize GStreamer; put the following code on the line above the <code>gtk_init</code> call in the <code>main</code> function:
cs: Tímto se vloží knihovna GStreamer. Potřebujete také přidat řádek inicializující GStreamer. Vložte následující kód na řádek nad volání <code>gtk_init</code> do funkce <code>main</code>:

note: (itstool) path: section/p
en: Then, copy the following function into <file>main.c</file> above the empty <code>on_button_clicked</code> function:
cs: Pak nakopírujte následující funkci do <file>main.c</file> nad prázdnou funkci <code>on_button_clicked</code>:

note: (itstool) path: section/code
en: static void
    play_sound (gdouble frequency)
    {
    	GstElement *source, *sink;
    	GstElement *pipeline;
    
    	pipeline = gst_pipeline_new ("note");
    	source   = gst_element_factory_make ("audiotestsrc",
    	                                     "source");
    	sink     = gst_element_factory_make ("autoaudiosink",
    	                                     "output");
    
    	/* set frequency */
    	g_object_set (source, "freq", frequency, NULL);
    
    	gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL);
    	gst_element_link (source, sink);
    
    	gst_element_set_state (pipeline, GST_STATE_PLAYING);
    
    	/* stop it after 500ms */
    	g_timeout_add (LENGTH, (GSourceFunc) pipeline_stop, pipeline);
    }
cs: static void
    play_sound (gdouble frequency)
    {
    	GstElement *source, *sink;
    	GstElement *pipeline;
    
    	pipeline = gst_pipeline_new ("note");
    	source   = gst_element_factory_make ("audiotestsrc",
    	                                     "source");
    	sink     = gst_element_factory_make ("autoaudiosink",
    	                                     "output");
    
    	/* nastaví frekvenci */
    	g_object_set (source, "freq", frequency, NULL);
    
    	gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL);
    	gst_element_link (source, sink);
    
    	gst_element_set_state (pipeline, GST_STATE_PLAYING);
    
    	/* zastaví to po 500 ms */
    	g_timeout_add (LENGTH, (GSourceFunc) pipeline_stop, pipeline);
    }

note: (itstool) path: item/p
en: 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).
cs: Prvních pět řádků vytvoří prvky GStreamer typu zdroj a cíl (<code>GstElement</code>) a prvek typu roura (který bude použit jako kontejner pro první dva prvky). Roura dostane název „note“. Zdroj je pojmenován „source“ a je nastaven jako <code>audiotestsrc</code>. Cíl je pojmenován „output“ a je nastaven jako <code>autoaudiosink</code> (výchozí výstup zvukové karty).

note: (itstool) path: item/p
en: The call to <code>g_object_set</code> sets the <code>freq</code> property of the source element to <code>frequency</code>, which is passed as an argument to the <code>play_sound</code> function. This is just the frequency of the note in Hertz; some useful frequencies will be defined later on.
cs: Volání <code>g_object_set</code> nastaví vlastnost <code>freq</code> zdrojového prvku na <code>frequency</code>, která byla předána jako argument funkci <code>play_sound</code>. Jedná se o frekvenci tónu v hertzích. Správné frekvence nadefinujeme později.

note: (itstool) path: item/p
en: <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>.
cs: <code>gst_bin_add_many</code> vloží zdroj a cíl do roury. Roura je <code>GstBin</code>, což je zase jen prvek, který může obsahovat více dalších prvků GStreamer. Obecně můžete přidat tolik prvků, kolik chcete, pomocí předáním více argumentů do <code>gst_bin_add_many</code>.

note: (itstool) path: item/p
en: 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>).
cs: Následně je <code>gst_element_link</code> použito k propojení prvků navzájem, takže výstup prvku <code>source</code> (tón) putuje do vstupu prvku <code>sink</code> (což je výstup do zvukové karty). <code>gst_element_set_state</code> je použito ke spuštění přehrávání nastavením stavu roury na přehrávání (<code>GST_STATE_PLAYING</code>).

note: (itstool) path: section/title
en: Stopping playback
cs: Zastavení přehrávání

note: (itstool) path: section/p
en: 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>.
cs: Nechceme ale hrát nějaký tón navždycky, takže poslední věcí, kterou <code>play_sound</code> udělá, je, že zavolá <code>g_timeout_add</code>. Tím se nastaví časový limit pro zastavení zvuku. Čeká v délce <code>LENGTH</code> milisekund a pak zavolá funkci <code>pipeline_stop</code>, která vrátí <code>FALSE</code>, jinak by se v jejím volání pokračovalo.

note: (itstool) path: section/p
en: Now, we'll write the <code>pipeline_stop</code> function which is called by <code>g_timeout_add</code>. Insert the following code <em>above</em> the <code>play_sound</code> function:
cs: Nyní budeme psát funkci <code>pipeline_stop</code>, která je volána z <code>g_timeout_add</code>. Vložte následující kód <em>nad</em> funkci <code>play_sound</code>:

note: (itstool) path: section/code
en: 
    #define LENGTH 500 /* Length of playing in ms */
    
    static gboolean
    pipeline_stop (GstElement* pipeline)
    {
    	gst_element_set_state (pipeline, GST_STATE_NULL);
    	g_object_unref (pipeline);
    
    	return FALSE;
    }
cs: 
    #define LENGTH 500 /* Délka přehrávání v ms */
    
    static gboolean
    pipeline_stop (GstElement* pipeline)
    {
    	gst_element_set_state (pipeline, GST_STATE_NULL);
    	g_object_unref (pipeline);
    
    	return FALSE;
    }

note: (itstool) path: section/p
en: The call to <code>gst_element_set_state</code> stops the playback of the pipeline and <code>g_object_unref</code> unreferences the pipeline, destroying it and freeing its memory.
cs: Zavolání <code>gst_element_set_state</code> zastaví přehrávání roury a <code>g_object_unref</code> zruší odkazy na rouru, zlikviduje ji a uvolní její paměť.

note: (itstool) path: section/title
en: Define the tones
cs: Definice tónů

note: (itstool) path: section/p
en: We want to play the correct sound when the user clicks a button. First of all, we need to know the frequencies for the six guitar strings, which are defined (at the top of <file>main.c</file>) as follows:
cs: Když uživatel klikne na tlačítko, chceme zahrát správný zvuk. Nejdříve ze všeho potřebujeme znát frekvence pro šest kytarových strun, které jsou definovány (na začátku <file>main.c</file>) následovně:

note: (itstool) path: section/code
en: 
    /* Frequencies of the strings */
    #define NOTE_E 329.63
    #define NOTE_A 440
    #define NOTE_D 587.33
    #define NOTE_G 783.99
    #define NOTE_B 987.77
    #define NOTE_e 1318.5
cs: 
    /* Řetězce pro jednotlivé frekvence */
    #define NOTE_E 329.63
    #define NOTE_A 440
    #define NOTE_D 587.33
    #define NOTE_G 783.99
    #define NOTE_B 987.77
    #define NOTE_e 1318.5

note: (itstool) path: section/p
en: 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:
cs: Nyní oživíme obsluhu signálu, kterou jsme zadeklarovali již dříve po názvem <code>on_button_clicked</code>. Mohli bychom mít napojená všechna tlačítka na různé obslužné funkce, ale to by vedlo ke zbytečné duplicitě kódu. Místo toho použijeme popisek každého z tlačítek ke zjištění, na které tlačítko bylo kliknuto:

note: (itstool) path: section/code
en: 
    /* Callback for the buttons */
    void on_button_clicked (GtkButton* button,
                            gpointer user_data)
    {
    	const gchar* text = gtk_button_get_label (button);
    
    	if (g_str_equal (text, _("E")))
    	    play_sound (NOTE_E);
    	else if (g_str_equal (text, _("A")))
    	    play_sound (NOTE_A);
    	else if (g_str_equal (text, _("G")))
    	    play_sound (NOTE_G);
    	else if (g_str_equal (text, _("D")))
    	    play_sound (NOTE_D);
    	else if (g_str_equal (text, _("B")))
    	    play_sound (NOTE_B);
    	else if (g_str_equal (text, _("e")))
    	    play_sound (NOTE_e);
    }
cs: 
    /* Zpětná volání pro tlačítka */
    void on_button_clicked (GtkButton* button,
                            gpointer user_data)
    {
    	const gchar* text = gtk_button_get_label (button);
    
    	if (g_str_equal (text, _("E")))
    	    play_sound (NOTE_E);
    	else if (g_str_equal (text, _("A")))
    	    play_sound (NOTE_A);
    	else if (g_str_equal (text, _("G")))
    	    play_sound (NOTE_G);
    	else if (g_str_equal (text, _("D")))
    	    play_sound (NOTE_D);
    	else if (g_str_equal (text, _("B")))
    	    play_sound (NOTE_B);
    	else if (g_str_equal (text, _("e")))
    	    play_sound (NOTE_e);
    }

note: (itstool) path: section/p
en: 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 text of that button using <code>gtk_button_get_label</code>.
cs: Ukazatel na <code>GtkButton</code>, na které bylo kliknuto je předán jako argument (<code>button</code>) do <code>on_button_clicked</code>. Text tohoto tlačítka můžeme získat pomocí <code>gtk_button_get_label</code>.

note: (itstool) path: section/p
en: The 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!
cs: Text se porovnává s notami, které máme pomocí <code>g_str_equal</code> a <code>play_sound</code> je voláno s příslušnou frekvencí odpovídající notě. Tím se zahraje tón a my máme konečně fungující kytarovou ladičku!

note: (itstool) path: section/title
en: Build and run the application
cs: Sestavení a spuštění aplikace

note: (itstool) path: section/p
en: 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.
cs: Celý kód by nyní měl být připravený k fungování. Klikněte na <guiseq><gui>Sestavit</gui> <gui>Sestavit projekt</gui></guiseq>, aby se vše znovu sestavilo a pak na <guiseq><gui>Spustit</gui> <gui>Spustit</gui></guiseq>, aby se aplikace spustila.

note: (itstool) path: section/p
en: 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!
cs: Pokud jste tak ještě neučinili, zvolte aplikaci <file>Debug/src/guitar-tuner</file> v dialogovém okně, které se objeví. Nakonec klikněte na <gui>Spustit</gui> a užijte si ji!

note: (itstool) path: section/title
en: Reference Implementation
cs: Ukázková implementace

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="guitar-tuner/guitar-tuner.c">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="guitar-tuner/guitar-tuner.c">ukázkovým kódem</link>.

note: (itstool) path: section/title
en: Next steps
cs: Další postup

note: (itstool) path: section/p
en: Here are some ideas for how you can extend this simple demonstration:
cs: Zde je pár nápadů, jak byste mohli tuto jednoduchou ukázku rozšířit:

note: (itstool) path: item/p
en: Have the program automatically cycle through the notes.
cs: Přidat do programu možnost dokola procházet tóny.

note: (itstool) path: item/p
en: Make the program play recordings of real guitar strings being plucked.
cs: Naučit program přehrávat nahrávky vybrnkání jednotlivých reálných kytarových strun.

note: (itstool) path: item/p
en: 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.
cs: Abychom to mohli udělat, potřebujeme sestavit mnohem složitější rouru GStreamer, která umožní načíst a přehrát hudební soubory. Budete muset zvolit prvky GStreamer typu <link href="http://gstreamer.freedesktop.org/documentation/plugins.html">dekodér a demultiplexor</link> podle formátu souborů s vašimi zvukovými nahrávkami – například MP3 používá jiné prvky než Ogg Vorbis.

note: (itstool) path: item/p
en: 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.
cs: Můžete také potřebovat prvky propojit mnohem komplikovanějším způsobem. Toho lze dosáhnout pomocí <link href="http://gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html/chapter-intro-basics.html">konceptů GStreamer</link>, které jsme v této lekci neprobírali. Mezi ně patří například <link href="http://gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html/section-intro-basics-pads.html">přípojné body</link>. Hodit se vám může také příkaz <cmd>gst-inspect</cmd>.

note: (itstool) path: item/p
en: Automatically analyze notes that the user plays.
cs: Automaticky analyzovat tóny, které uživatel zahraje.

note: (itstool) path: item/p
en: 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?
cs: Mohli byste připojit mikrofón a nahrávat z něj zvuky pomocí <link href="http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-good-plugins/html/gst-plugins-good-plugins-autoaudiosrc.html">vstupního zdroje</link>. Zjistit, který tón je přehráván, by vám možná pomohla <link href="http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-good-plugins/html/gst-plugins-good-plugins-plugin-spectrum.html">spektrální analýza</link>.

note: (itstool) path: info/desc
en: Use GTKmm and GStreamermm to build a simple guitar tuner application for GNOME. Shows off how to use the interface designer.
cs: Jak použít GTKmm a GStreamermm k sestavení jednoduché aplikace pro GNOME fungující jako kytarová ladička. Předvedeme si, jako používat návrhář rozhraní.

note: (itstool) path: item/p
en: Basic knowledge of the C++ programming language
cs: Základní znalosti programování v jazyce C++

note: (itstool) path: item/p
en: Choose <gui>GTKmm (Simple)</gui> from the <gui>C++</gui> tab, click <gui>Forward</gui>, and fill out your details on the next few pages. Use <file>guitar-tuner</file> as project name and directory.
cs: Na kartě <gui>C++</gui> zvolte <gui>GTKmm (jednoduchý)</gui>. Klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>guitar-tuner</file>.

note: (itstool) path: item/p
en: 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.
cs: Ujistěte se, že <gui>Konfigurovat externí balíčky</gui> je zapnuto. Na následující stránce vyberte v seznamu <em>gstreamermm-0.10</em>, aby se knihovna GStreamer zahrnula do vašeho projektu.

note: (itstool) path: item/p
en: Click <gui>Finished</gui> and the project will be created for you. Open <file>src/main.cc</file> from the <gui>Project</gui> or <gui>File</gui> tabs. You should see some code which starts with the lines:
cs: Klikněte na <gui>Dokončit</gui> a projekt se vám vytvoří. Otevřete <file>src/main.cc</file> z karty <gui>Projekt</gui> nebo <gui>Soubor</gui>. Měli byste vidět kód začínající řádky:

note: (itstool) path: section/p
en: This is a very basic C++ code setting up GTKmm. More details are given below; skip this list if you understand the basics:
cs: Jedná se o zcela základní kód C++ nastavující GTKmm. Podrobněji je to popsáno dále. Pokud základům rozumíte, tak tento sezmam přeskočte:

note: (itstool) path: item/p
en: 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.
cs: Tři řádky s <code>#include</code> na začátku vkládají <code>config</code> (užitečný pro definice sestavení pomocí autoconf), <code>gtkmm</code> (uživatelské rozhraní) a <code>iostream</code> (STL). Funkce z těchto knihoven jsou použity ve zbytku kódu.

note: (itstool) path: item/p
en: 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.
cs: Funkce <code>main</code> vytvoří nové okno otevřením souboru GtkBuilder (<file>src/guitar-tuner.ui</file> definovaný a pár řádků dřív) a zobrazí jej v okně. Soubor obsahuje popis uživatelského rozhraní a všech jeho prvků. K návrhu uživatelského rozhraní můžete použít editor v IDE Anjuta.

note: (itstool) path: item/p
en: 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).
cs: Poté se volá několik funkcí, které nastaví a spustí aplikaci. Funkce <code>kit.run</code> spustí hlavní smyčku GTKmm, která spustí uživatelské rozhraní a začne naslouchat událostem (jako jsou kliknutí nebo zmáčknutí kláves).

note: (itstool) path: item/p
en: 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.
cs: Dokud je tlačítko ještě vybráno, změňte vlastnost <gui>Popisek</gui> na kartě <gui>Widgety</gui> na <gui>E</gui>. Bude se jednat o dolní strunu E. Také změňte vlastnost <gui>Název</gui> na <gui>button_E</gui>. Tímto názvem se na widget budeme později odkazovat v kódu.

note: (itstool) path: item/p
en: Repeat the above steps for the other buttons, adding the next 5 strings with the labels <em>A</em>, <em>D</em>, <em>G</em>, <em>B</em>, and <em>e</em> and the names <em>button_A</em>, etc.
cs: Opakujte předchozí kroky po ostatní tlačítka, tj. přidejte dalších 5 řetězců s popisky <em>A</em>, <em>D</em>, <em>G</em>, <em>B</em> a <em>e</em> a názvy <em>button_A</em>, atd.

note: (itstool) path: item/p
en: Save the UI design (by clicking <guiseq><gui>File</gui><gui>Save</gui></guiseq>) and close the file.
cs: Uložte návrh uživatelského rozhraní (kliknutím na <guiseq><gui>Soubor</gui> <gui>Uložit</gui></guiseq>) a soubor zavřete.

note: (itstool) path: section/p
en: GStreamer is GNOME's multimedia framework — you can use it for playing, recording, and processing video, audio, webcam streams and the like. Here, we'll be using it to produce single-frequency tones. GStreamermm is the C++ binding to GStreamer which we will use here.
cs: GStreamer je základní multimediální rámec GNOME. Můžete jej použít k přehrávání, nahrávání a zpracování videa, zvuku, vysílání z webové kamery a podobně. Zde jej použijeme ke generování tónu s jednou frekvencí. GStreamermm je vazba C++ na GStreamer, kterou zde použijeme.

note: (itstool) path: section/title
en: Using GStreamermm
cs: Používání GStreamermm

note: (itstool) path: section/p
en: To use GStreamermm, it has to be initialised. We do that by adding the following line of code next to the <code>Gtk::Main kit(argc, argv);</code> line in <file>main.cc</file>:
cs: Aby bylo možné používat knihovnu GStreamermm, je nutné ji inicializovat. To provedeme přidáním následujícího řádku s kódem za řádek <code>Gtk::Main kit(argc, argv);</code> v <file>main.cc</file>:

note: (itstool) path: section/p
en: While we are on it, also make sure that the <file>gstreamermm.h</file> is included in <file>main.cc</file> properly.
cs: Když jsme u toho, ujistěte se také, že v <file>main.cc</file> je správně deklarováno <code>include</code> pro <file>gstreamermm.h</file>.

note: (itstool) path: section/p
en: To simplify the handling of the pipeline we will define a helper class <code>Sound</code>. We do that in <file>main.cc</file> in order to keep this example simple, whereas you might usually want to use a separate file:
cs: Pro zjednodušení práce s rourou nadefinujeme pomocnou třídu <code>Sound</code>. Provedeme to v <file>main.cc</file>, abychom zachovali tuto ukázku jednoduchou, ale normálně byste k tomu použili samostatný soubor:

note: (itstool) path: section/code
en: 
    class Sound
    {
    	public:
    		Sound();
    
    		void start_playing(double frequency);
    		bool stop_playing();
    
    	private:
    		Glib::RefPtr&lt;Gst::Pipeline&gt; m_pipeline;
    		Glib::RefPtr&lt;Gst::Element&gt; m_source;
    		Glib::RefPtr&lt;Gst::Element&gt; m_sink;
    };
    
    Sound::Sound()
    {
    	m_pipeline = Gst::Pipeline::create("note");
    	m_source = Gst::ElementFactory::create_element("audiotestsrc",
    	                                               "source");
    	m_sink = Gst::ElementFactory::create_element("autoaudiosink",
    	                                             "output");
    	m_pipeline-&gt;add(m_source);
    	m_pipeline-&gt;add(m_sink);
    	m_source-&gt;link(m_sink);
    }
    
    void Sound::start_playing (double frequency)
    {
    	m_source-&gt;set_property("freq", frequency);
    	m_pipeline-&gt;set_state(Gst::STATE_PLAYING);
    
    	/* stop it after 200ms */
    	Glib::signal_timeout().connect(sigc::mem_fun(*this, &amp;Sound::stop_playing),
    	                               200);
    }
    
    bool Sound::stop_playing()
    {
    	m_pipeline-&gt;set_state(Gst::STATE_NULL);
    	return false;
    }
cs: 
    class Sound
    {
    	public:
    		Sound();
    
    		void start_playing(double frequency);
    		bool stop_playing();
    
    	private:
    		Glib::RefPtr&lt;Gst::Pipeline&gt; m_pipeline;
    		Glib::RefPtr&lt;Gst::Element&gt; m_source;
    		Glib::RefPtr&lt;Gst::Element&gt; m_sink;
    };
    
    Sound::Sound()
    {
    	m_pipeline = Gst::Pipeline::create("note");
    	m_source = Gst::ElementFactory::create_element("audiotestsrc",
    	                                               "source");
    	m_sink = Gst::ElementFactory::create_element("autoaudiosink",
    	                                             "output");
    	m_pipeline-&gt;add(m_source);
    	m_pipeline-&gt;add(m_sink);
    	m_source-&gt;link(m_sink);
    }
    
    void Sound::start_playing (double frequency)
    {
    	m_source-&gt;set_property("freq", frequency);
    	m_pipeline-&gt;set_state(Gst::STATE_PLAYING);
    
    	/* Zastaví to po 200 ms */
    	Glib::signal_timeout().connect(sigc::mem_fun(*this, &amp;Sound::stop_playing),
    	                               200);
    }
    
    bool Sound::stop_playing()
    {
    	m_pipeline-&gt;set_state(Gst::STATE_NULL);
    	return false;
    }

note: (itstool) path: section/p
en: The code has the following purpose:
cs: Kód má následující účel:

note: (itstool) path: item/p
en: 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.
cs: V konstruktoru se vytvoří prvky GStreamer typu zdroj a cíl (<code>Gst::Element</code>) a prvek typu roura (který bude použit jako kontejner pro první dva prvky). Roura dostane název „note“. Zdroj je pojmenován „source“ a je nastaven jako <code>audiotestsrc</code>. Cíl je pojmenován „output“ a je nastaven jako <code>autoaudiosink</code> (výchozí výstup zvukové karty). Jakmile jsou prvky přidány do roury a spojeny dohromady, je roura připravena k použití.

note: (itstool) path: item/p
en: <code>start_playing</code> sets the source element to play a particular frequency and then starts the pipeline so the sound actually starts playing. As we don't want to have the annoying sound for ages, a timeout is set up to stop the pipeline after 200 ms by calling <code>stop_playing</code>.
cs: <code>start_playing</code> nastaví zdrojový prvek, aby hrál příslušnou frekvenci, a následně spustí rouru, takže zvuk se začne opravdu hrát. Protože tento zvuk nechceme poslouchat navěky, nastavíme časový limit pro zastavení roury pomocí volání <code>stop_playing</code> po 200 ms.

note: (itstool) path: item/p
en: 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.
cs: Ve funkci <code>stop_playing</code>, která je zavolána po uplynutí časového limitu, je zastavena roura a zvuk tak přestané znít. GStreamermm používá počítání odkazů pomocí objektu <code>Glib::RefPtr</code>, takže po zlikvidování třídy <code>Sound</code> je paměť automaticky uvolněna.

note: (itstool) path: section/title
en: Connecting the signals
cs: Připojení signálů

note: (itstool) path: section/p
en: We want to play the correct sound when the user clicks a button. That means that we have to connect to the signal that is fired when the user clicks the button. We also want to provide information to the called function which tone to play. GTKmm makes that quite easy as we can easily bind information with the <em>sigc</em> library.
cs: Když uživatel klikne na tlačítko, chceme přehrát správný zvuk. To znamená, že musíme napojit signál, který je spuštěn uživatelovým kliknutím na tlačítko. Také chceme volané funkci poskytnout informaci, který tón má zahrát. GTKmm toto usnadňuje, protože můžeme lehce propojit informace s knihovnou <em>sigc</em>.

note: (itstool) path: section/p
en: 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:
cs: Funkce, která je volána, když uživatel klikne na tlačítko, může být hezky jednoduchá, protože všechny zajímavé věci jsou nyní provedeny v pomocí třídě:

note: (itstool) path: section/p
en: 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.
cs: Toto je jen pomocná třída, kterou jsem nadeklarovali dříve, aby přehrávala správné frekvence. Kvůli přehlednějšímu kódy bychom také měli být schopni napojit se přímo do třídy bez použití funkce, ale necháme to tak, kvůli použití jako příkladu.

note: (itstool) path: section/p
en: 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:
cs: Kód nastavující signály by měl být přidán do funkce <code>main()</code> přímo za řádek <code>builder-&gt;get_widget("main_window", main_win);</code>:

note: (itstool) path: item/p
en: 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.
cs: Nejprve vytvoříme instanci naší pomocné třídy, kterou chceme nyní použít a deklarujeme proměnnou pro tlačítko, které na ni chceme napojit.

note: (itstool) path: item/p
en: 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.
cs: Následně obdržíme objekt tlačítka od uživatelského rozhraní, které bylo vytvořeno ze souboru s uživatelským rozhraním. Pamatujte, že <em>button_E</em> je název, který jsme dali prvnímu tlačítku.

note: (itstool) path: item/p
en: 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.
cs: Nakonec napojíme signál <em>clicked</em>. To není úplně přímočaré, protože je to uděláno typově plně bezpečným způsobem a prakticky chceme obsluze signálu předat frekvenci a naši pomocnou třídu. <code>sigc::ptr_fun(&amp;on_button_clicked)</code> vytvoří <em>slot</em> pro metodu <code>on_button_clicked</code>, kterou jsme nadefinovali dříve. Pomocí <code>sigc::bind</code> jsme schopni předat dodatečné argumenty do slotu a v tomto případě tak předáme frekvenci (jako <code>double</code>) a naši pomocnou třídu.

note: (itstool) path: section/p
en: 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.
cs: Teď, když máte nastavené tlačítko <em>E</em>, musíme propojit ostatní tlačítka s jejich správnými frekvencemi: 440 pro A, 587.33 pro D, 783.99 pro G, 987.77 pro H (v anglické notaci B) a 1318.5 pro horní E. To se provede stejným způsobem, akorát se obsluze předá jiná frekvence.

note: (itstool) path: section/p
en: 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.
cs: Celý kód je nyní připraven ke spuštění. Klikněte na <guiseq><gui>Sestavit</gui> <gui>Sestavit projekt</gui></guiseq>, aby se vše znovu sestavilo, a pak na <guiseq><gui>Spustit</gui> <gui>Spustit</gui></guiseq>, aby se aplikace spustila.

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="guitar-tuner/guitar-tuner.cc">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="guitar-tuner/guitar-tuner.cc">ukázkovým kódem</link>.

note: (itstool) path: section/title
en: Further Reading
cs: Náměty ke čtení

note: (itstool) path: section/p
en: 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>.
cs: Řada věcí předvedených výše je podrobně vysvětlena v <link href="http://library.gnome.org/devel/gtkmm-tutorial/stable/">Kniha o GTKmm</link>, která se zabývá více i klíčovými koncepty pro plnohodnotné použití GTKmm. Mohla by vás zajímat i <link href="http://library.gnome.org/devel/gstreamermm/">referenční dokumentace GStreamermm</link>.

[ctx: text]
note: (itstool) path: info/title
en: Guitar tuner (JavaScript)
cs: Kytavorá ladička (JavaScript)

note: (itstool) path: info/desc
en: Use GTK+ and GStreamer to build a simple guitar tuner application for GNOME.
cs: Používá GTK+ a GStreamer k sestavení jednoduché aplikace pro GNOME s funkcionalitou kytarové ladičky.

note: (itstool) path: synopsis/p
en: In this tutorial we'll construct a small application, Guitar Tuner, using JavaScript and GTK+ and GStreamer. To do and run all the code examples yourself, you need an editor to write code in, terminal and GNOME 3. or higher installed into your computer.
cs: V této lekci sestavíme malou aplikaci, kytarovou ladičku, pomocí jazyka JavaScript a knihoven GTK+ a GStreamer. Abyste tak mohli učinit a spustit si kód z příkladu, budete potřebovat nainstalovaný editor pro psaní kódu, terminál a GNOME 3.0 nebo novější.

note: (itstool) path: item/p
en: <link xref="#gstreamer">GStreamer pipelines</link>
cs: <link xref="#gstreamer">Roury systému GStreamer</link>

note: (itstool) path: item/p
en: <link xref="#script">Script for running the application</link>
cs: <link xref="#script">Skript pro spuštění aplikace</link>

note: (itstool) path: item/p
en: <link xref="#imports">Libraries to import</link>
cs: <link xref="#imports">Importované knihovny</link>

note: (itstool) path: item/p
en: <link xref="#mainwindow">Creating the main window for the application</link>
cs: <link xref="#mainwindow">Vytvoření hlavního okna pro aplikaci</link>

note: (itstool) path: item/p
en: <link xref="#buttons">Buttons for the tunes</link>
cs: <link xref="#buttons">Tlačítka pro ladění</link>

note: (itstool) path: item/p
en: <link xref="#playSound">Making the sounds with GStreamer</link>
cs: <link xref="#playSound">Vyluzování zvuků systémem GStreamer</link>

note: (itstool) path: item/p
en: <link xref="#connecting">Connecting buttons to playSound</link>
cs: <link xref="#connecting">Napojení tlačítek na playSound</link>

note: (itstool) path: item/p
en: <link xref="#guitarjs">The whole program</link>
cs: <link xref="#guitarjs">Celý program</link>

note: (itstool) path: item/p
en: <link xref="#terminal">Running the application form Terminal</link>
cs: <link xref="#terminal">Spuštění aplikace z terminálu</link>

note: (itstool) path: page/p
en: After reading this tutorial, you should see this in your screen:
cs: Po přečtení této lekce byste měli na obrazovce dostat toto:

note: (itstool) path: section/title
en: Script for running the application
cs: Skript pro spuštění aplikace

note: (itstool) path: section/p
en: This line tells how to run the script. It needs to be the first line of the code and it needs to be executable. To get the execution rights go to terminal and run in right folder: chmod +x scriptname. Or you can use the graphical filemanager. Just go to the right folder where your code is, right click you code file, choose properties, click the permissions tab and check the box for allow executing file as a program
cs: Tento řádek říká, jak spustit skript. Musí být prvním řádek v souboru s kódem a soubor musí být spustitelný. Abyste získali práva na spuštění, jděte do terminálu a ve správné složce spusťte: chmod +x název_skriptu. Nebo můžete použít grafického správce souborů. Přejděte do správné složky s vašim kódem, klikněte na soubor s kódem pravým tlačítkem, zvolte vlastnosti, klikněte na kartu oprávnění a zaškrtněte políčko, které povoluje spuštění souboru jako programu.

note: (itstool) path: section/p
en: In order to have a working program we need to import a few GObject Introspection -libraries to our use. For working UI, we need Gtk and for Gstreamer to work we need Gst. These are imported in the beginning so we have them at use everywhere. Also in the beginning we import a construct Mainloop to handle the timeout to be used with the tuning sounds.
cs: Abychom dostali fungující program, potřebujeme naimportovat pár GObject Introspection, tj. knihoven, pro naše použití. Pro fungující uživatelské rozhraní potřebujeme Gtk a pro GStreamer potřebujeme Gst. Import se provádí hned na začátku, takže budou fungovat všude. Na začátku také naimportujeme konstrukt Mainloop, který se bude starat o časové omezení při vydávání ladicích tónů.

note: (itstool) path: section/title
en: Creating the main window for the application
cs: Vytvoření hlavního okna pro aplikaci

note: (itstool) path: section/p
en: Importing Gtk and Gst is not enough, we need to initialize them in order to get them working. When Gtk and Gst are up and running we need to create the window for the application. Later we are going to put all the buttons for making sounds inside this window. In order to get the window showing, we need to tell it to show and we need also to run the code with the Gtk.main()
cs: Jen naimportovat Gtk a Gst nestačí, je třeba je inicializovat, aby fungovaly. Když jsou Gtk a Gst nastavené a běží, potřebujeme vytvořit okno pro aplikaci. Později do tohoto okna vložíme všechna tlačítka pro vydávání tónů. Aby se okno zobrazilo, musíme mu říci, ať se zobrazí, a také musíme spustit kód s <code>Gtk.main()</code>.

note: (itstool) path: section/title
en: Buttons for the tunes
cs: Tlačítka pro ladění

note: (itstool) path: section/p
en: Because Gtk.Window can only contain a single widget, we need to create something under it to be able to add all the necessary buttons inside it. In this example we use Buttonbox. After creating the Buttonbox we create buttons with necessary labels. After we have the buttons we need to add them to the Buttonbox and the Buttonbox must be added to the Gtk.Window and everything in the Buttonbox must be shown.
cs: Protože <code>Gtk.Window</code> může obsahovat jen jediný widget, potřebujeme vytvořit nějaký další podkladový, který bude schopný do sebe přidat všechna tlačítka. V tomto příkladu použijeme <code>Buttonbox</code> (box na tlačítka). Po jeho vytvoření vytvoříme tlačítka s patřičnými popisky. Když máme tlačítka, musíme je přidat do kontejneru Buttonbox a ten musíme přidat do Gtk.Window a vše v boxu na tlačítka se musí zobrazit.

note: (itstool) path: section/p
en: After this stage you should have a window appearing to your screen showing 6 buttons. Right now the buttons don't do anything and we shall address that issue later. Before we can connect the button signals to something we need to code that something first.
cs: Po této fázi byste měli mít okno, které se ukáže na obrazovce a zobrazí šest tlačítek. Je v pořádku, že tlačítka nic nedělají, to budeme řešit později. Než vůbec můžeme někam napojit signály tlačítek, musíme ono „někam“ nejdříve naprogramovat.

note: (itstool) path: section/title
en: Making the sounds with GStreamer
cs: Vyluzování zvuků systémem GStreamer

note: (itstool) path: section/p
en: The first thing we need to do is decide what tunes we want to make when we push a button. The frequencies list takes care of that. After that we get to actually making the sounds with the function playSound. For function playSound we give as an input a frequency (that we just defined in the frequencies variable). First thing we need to construct is a pipeline, a source and a sink. For the source we set the frequency. To the pipeline we add both the source and the sink and then we tell it to keep playing. As a last thing we use the const Mainloop to get the pipeline to stop after a 500ms.
cs: Nejprve se musíme rozhodnout, jaké tóny chceme při zmáčknutí tlačítka vyloudit. O to se postará seznam frekvencí. Tím se dostáváme k tomu, jak vydat zvuk ve funkci <code>playSound</code>. Té jako vstup předáváme frekvenci (ty jsme právě nadefinovali do proměnné). Jako první musíme sestrojit rouru, zdroj a cíl. Zdroji nastavíme frekvenci. K rouře přidáme zdroj i cíl a pak řekneme, ať to hraje. Jako poslední věc použijeme objekt <code>Mainloop</code> k zastavení roury po 500 ms.

note: (itstool) path: section/p
en: Now we have the method of playing a tune when clicking a button. Next well make the connections between pushing a button and playing the correct sound from that button.
cs: Nyní máme způsob, jak přehrát tón při kliknutí na tlačítko. Takže jako další krok propojíme zmáčknutí tlačítka s přehráním správného tónu.

note: (itstool) path: section/title
en: Connecting buttons to playSound
cs: Napojení tlačítek na playSound

note: (itstool) path: section/p
en: The method of connecting button clicks to playSound with the correct tune is by using the connect method of the button widget. So we choose a button to be connected and type <code>E.connect("clicked", function(){playSound(frequencies.E);});</code> The <code>connect</code> tells that when pushing E, something should happen. The <code>clicked</code> tells the type of the signal happening to E and then in the <code>function(){};</code> we call playSound with the correct note that should be associated with the button.
cs: Způsob propojení kliknutí na tlačítko a funkce <code>playSound</code> se správným tónem se provede pomocí metody <code>connect</code> widgetu tlačítka. Zvolíme napojované tlačítko a napíšeme <code>E.connect("clicked", function(){playSound(frequencies.E);});</code>. Metoda <code>connect</code> říká, že když se zmáčkne E, má se něco stát. Řetězec <code>"clicked"</code> říká, o jaký typ signálu se u tlačítka jedná a funkce <code>function(){};</code> volá <code>playSound</code> se správnou notou, která k tlačítku patří.

note: (itstool) path: section/title
en: The whole program
cs: Celý program

note: (itstool) path: section/p
en: So this is what all the parts combined looks like. When running this code, you should be able to tune your guitar (if you have correctly calibrated speakers).
cs: Takže všechny části spojené dohromady vypadají takto. Když spustíte tento kód, měli byste být schopni naladit si svoji kytaru (pokud máte správně zkalibrované reproduktory).

note: (itstool) path: section/title
en: Running the application form Terminal
cs: Spuštění aplikace z terminálu

note: (itstool) path: section/p
en: To run this application open Terminal, go to the folder where your application is stored and then run
cs: Pro spuštění aplikace otevřete terminál, přejděte do složky, kde je vaše aplikace uložená a pak ji spusťte

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="guitar-tuner/guitar-tuner.js">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="guitar-tuner/guitar-tuner.js">ukázkovým kódem</link>.

[ctx: text]
note: (itstool) path: info/title
en: Guitar tuner (Python)
cs: Kytarová ladička (Python)

note: (itstool) path: item/p
en: Basic knowledge of the Python programming language
cs: Základní znalosti programovacího jazyka Python

note: (itstool) path: item/p
en: Choose <gui>PyGTK (automake)</gui> from the <gui>Python</gui> tab, click <gui>Continue</gui>, and fill out your details on the next few pages. Use <file>guitar-tuner</file> as project name and directory.
cs: Na kartě <gui>Python</gui> zvolte <gui>PyGTK (automake)</gui>, klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>guitar-tuner</file>.

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. Open <file>src/guitar_tuner.py</file> from the <gui>Project</gui> or <gui>File</gui> tabs. You should see some code which starts with the lines:
cs: Klikněte na <gui>Použít</gui> a vytvoří se vám projekt. Otevřete <file>src/guitar_tuner.py</file> na kartě <gui>Projekt</gui> nebo <gui>Soubor</gui>. Měli byste vidět kód, který začíná řádky:

note: (itstool) path: section/title
en: Run the code for the first time
cs: Spuštění kódu poprvé

note: (itstool) path: section/p
en: 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:
cs: Většina toho je kód šablony. Načte (prázdné) okno ze souboru s popisem uživatelského rozhraní a zobrazí jej. Dále to podrobněji rozebereme. Pokud jste již pochopili základy, tak tento seznam můžete přeskočit:

note: (itstool) path: item/p
en: The <code>import</code> lines at the top include the tell Python to load the user interface and system libraries needed.
cs: Řádky <code>import</code> na začátku říkají interpretru jazyka Pyton, aby načetl uživatelské rozhraní a potřebné systémové knihovny.

note: (itstool) path: item/p
en: 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.
cs: Zde deklarovaná třída bude hlavní třídou pro naši aplikaci. V metodě <code>__init__</code> se načte hlavní okno ze souboru GtkBuilder (<file>src/guitar-tuner.ui</file>) a napojí se signály.

note: (itstool) path: item/p
en: 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.
cs: Napojení signálu je způsob, jak definovat, co se má stát, když zmáčknete tlačítko nebo se prostě něco přihodí. Zde je zavolána metoda <code>destroy</code> (a ukončení aplikace) při zavření okna.

note: (itstool) path: item/p
en: 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.
cs: Funkce <code>main</code> se spustí jako výchozí, když spustíte aplikaci v jazyce Python. Vytvoří instanci hlavní třídy a spustí hlavní smyčku, aby se zobrazilo okno.

note: (itstool) path: section/p
en: This code is ready to be used, so you can run it by clicking <guiseq><gui>Run</gui><gui>Execute</gui></guiseq>.
cs: Kód je připraven k použití, takže jej můžete spustit kliknutím na <guiseq><gui>Spustit</gui> <gui>Spustit</gui></guiseq>.

note: (itstool) path: section/p
en: A description of the user interface (UI) is contained in the GtkBuilder file. To edit the user interface, open <file>src/guitar_tuner.ui</file>. This will switch to the interface designer. The design window is in the center; widgets and widgets' properties are on the right, and the palette of available widgets is on the left.
cs: Popis uživatelského rozhraní se nachází v souboru GtkBuilder. Když chcete uživatelské rozhraní upravit, otevřete <file>src/guitar_tuner.ui</file>. Přepnete se tím do návrháře rozhraní. Navrhované okno je uprostřed, widgety a jejich vlastnosti jsou napravo a paleta dostupných widgetů je nalevo.

note: (itstool) path: section/title
en: Write the signal handler
cs: Psaní obsluhy signálu

note: (itstool) path: section/p
en: To do this, open <file>guitar_tuner.py</file> while the user interface file is still open. Switch to the <gui>Signals</gui> tab, which you already used to set the signal name. Now take the row where you set the <gui>clicked</gui> signal and drag it into to the source file inside the class. The following code will be added to your source file:
cs: K tomu otevřete <file>guitar_tuner.py</file> a soubor s uživatelským rozhraním při tom ponechte stále otevřený. Přepněte se na kartu <gui>Signály</gui>, kterou jste již použili pro nastavení názvu signálu. Nyní chytněte řádek, na kterém jste nastavili signál <gui>clicked</gui> a přetáhněte jej do zdrojového kódu dovnitř třídy. Do zdrojového kódu se přidá následující kód:

note: (itstool) path: section/p
en: This signal handler has two arguments: the usual Python class pointer, and the <code>Gtk.Button</code> that called the function.
cs: Tato obsluha signálu má dva argumenty: ukazatel na běžnou třídu jazyka Python a <code>Gtk.Button</code>, které funkci zavolalo.

note: (itstool) path: section/p
en: Change the import line in <file>guitar_tuner.py</file>, just at the beginning to :
cs: Změňte řádek s <code>import</code> v <file>guitar_tuner.py</file>, aby začínal:

note: (itstool) path: section/p
en: 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:
cs: <code>Gst</code> vloží knihovnu GStreamer. Musíte ji také správně inicializovat, což je uděláno v metodě <code>main()</code> tímto voláním přidaným nad řádek <code>app = GUI()</code>:

note: (itstool) path: section/p
en: Then, copy the following function into the class in <file>guitar_tuner.py</file> somewhere:
cs: Potom nakopírujte následující funkci kamkoliv do třídy <file>guitar_tuner.py</file>:

note: (itstool) path: item/p
en: 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).
cs: První tři řádky vytvoří prvky GStreamer typu zdroj a cíl a prvek typu roura (který bude použit jako kontejner pro první dva prvky). Roura dostane název „note“. Zdroj je pojmenován „source“ a je nastaven jako <code>audiotestsrc</code>. Cíl je pojmenován „output“ a je nastaven jako <code>autoaudiosink</code> (výchozí výstup zvukové karty).

note: (itstool) path: item/p
en: 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.
cs: Volání <code>source.set_property</code> nastaví vlastnost <code>freq</code> prvku <code>source</code> na frekvenci <code>frequency</code>, která je předána jako argument do funkce <code>play_sound</code>. Jedná se o frekvenci v Hertzích. Správné frekvence nadefinujeme později.

note: (itstool) path: item/p
en: 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.
cs: Následující dva řádky volají <code>pipeline.add</code>, čímž se vloží zdroj a cíl do roury. Roura může obsahovat více dalších prvků GStreamer. Obecně můžete přidat tolik prvků, kolik chcete, tak, že zavoláte metodu <code>add</code> opakovaně.

note: (itstool) path: item/p
en: Next <code>pipeline.set_state</code> is used to start playback, by setting the state of the pipeline to playing (<code>Gst.State.PLAYING</code>).
cs: Následující <code>pipeline.set_state</code> je použito ke spuštění přehrávání tím, že se nastaví stav roury na přehrávání (<code>Gst.State.PLAYING</code>).

note: (itstool) path: section/p
en: 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>.
cs: Nechceme ale hrát nějaký tón navždycky, takže poslední věcí, kterou <code>play_sound</code> udělá, je že zavolá <code>GObject.timeout_add</code>. Tím se nastaví časový limit pro zastavení zvuku. Čeká v délce <code>LENGTH</code> milisekund a pak zavolá funkci <code>pipeline_stop</code>, která vrátí <code>False</code>, jinak by se v jejím volání pokračovalo.

note: (itstool) path: section/p
en: Now, we'll write the <code>pipeline_stop</code> function which is called by <code>GObject.timeout_add</code>. Insert the following code <em>above</em> the <code>play_sound</code> function:
cs: Nyní napíšeme funkci <code>pipeline_stop</code>, která je volána z <code>GObject.timeout_add</code>. Vložte následující kód <em>nad</em> funkci <code>play_sound</code>:

note: (itstool) path: section/p
en: You need to define the <code>LENGTH</code> constant inside the class, so add this code at the beginning of the main class:
cs: Konstantu <code>LENGTH</code> je třeba definovat uvnitř třídy, takže tento kód přidáme na začátek třídy main:

note: (itstool) path: section/p
en: The call to <code>pipeline.set_state</code> stops the playback of the pipeline.
cs: Zavolání <code>pipeline.set_state</code> zastaví přehrávání roury.

note: (itstool) path: section/p
en: We want to play the correct sound when the user clicks a button. First of all, we need to know the frequencies for the six guitar strings, which are defined (at the beginning of the main class) inside a dictionary so we can easily map them to the names of the strings:
cs: Když uživatel klikne na tlačítko, chceme zahrát správný zvuk. Ze všeho nejdříve potřebujeme vědět frekvence pro šest kytarových strun, které jsou definovány (na začátku třídy main) ve slovníku, který můžeme jednoduše mapovat na názvy těchto strun:

note: (itstool) path: section/code
en: 
    # Frequencies of the strings
    frequencies = {
    	'E': 329.63,
    	'A': 440,
    	'D': 587.33,
    	'G': 783.99,
    	'B': 987.77,
    	'e': 1318.5
    }
cs: 
    # Řetězce pro frekvence
    frequencies = {
    	'E': 329.63,
    	'A': 440,
    	'D': 587.33,
    	'G': 783.99,
    	'B': 987.77,
    	'e': 1318.5
    }

note: (itstool) path: section/p
en: 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>.
cs: Tlačítko, na které bylo kliknuto, je předáno jako argument <code>tlačítko</code> do <code>on_button_clicked</code>. Pomocí <code>button.get_child</code> můžeme získat popisek tohoto tlačítka a následně pomocí <code>label.get_label</code> získat text z tohoto popisku.

note: (itstool) path: section/p
en: 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!
cs: Text popisku je použit jako klíč do slovníku a funkce <code>play_sound</code> je zavolána s příslušnou frekvencí pro tuto notu. Tím se zahraje tón – máme funkční kytarovou ladičku!

note: (itstool) path: section/title
en: Run the application
cs: Spuštění aplikace

note: (itstool) path: section/p
en: All of the code should now be ready to go. Click <guiseq><gui>Run</gui><gui>Execute</gui></guiseq> to start the application. Enjoy!
cs: Všechen kód je nyní připravený k použití. Klikněte na <guiseq><gui>Spustit</gui> <gui>Spustit</gui></guiseq>, aby se aplikace spustila a užijte si ji!

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="guitar-tuner/guitar-tuner.py">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="guitar-tuner/guitar-tuner.py">ukázkovým kódem</link>.

note: (itstool) path: info/desc
en: Use <link href="http://developer.gnome.org/platform-overview/stable/gtk">GTK+</link> and <link href="http://developer.gnome.org/platform-overview/stable/gstreamer">GStreamer</link> to build a simple guitar tuner application for GNOME. Shows off how to use the interface designer.
cs: Pomocí <link href="http://developer.gnome.org/platform-overview/stable/gtk">GTK+</link> a <link href="http://developer.gnome.org/platform-overview/stable/gstreamer">GStreamer</link> sestavíme jednoduchou aplikaci GNOME fungující jako kytarová ladička. Ukážeme si také, jak používat návrhář rozhraní.

note: (itstool) path: synopsis/p
en: In this tutorial you will create an application which plays tones that you can use to tune a guitar. You will learn how to:
cs: V této lekci vytvoříte aplikaci, která přehrává tóny, které můžete použít k naladění kytary. Naučíte se:

note: (itstool) path: item/p
en: Set up a basic project using the <link xref="getting-ready">Anjuta IDE</link>.
cs: Vytvořit základní projekt pomocí <link xref="getting-ready">IDE Anjuta</link>.

note: (itstool) path: item/p
en: Create a simple GUI with <app>Anjuta</app>'s UI designer.
cs: Vytvořit jednoduché GUI v návrháři uživatelského rozhraní <app>Anjuta</app>.

note: (itstool) path: item/p
en: Use the <link href="http://developer.gnome.org/platform-overview/stable/gstreamer">GStreamer</link> library to play sounds.
cs: Používat knihovnu <link href="http://developer.gnome.org/platform-overview/stable/gstreamer">GStreamer</link> k přehrávání zvuků.

note: (itstool) path: item/p
en: Basic knowledge of the <link href="https://live.gnome.org/Vala/Tutorial">Vala</link> programming language.
cs: Základní znalosti programovacího jazyka <link href="https://live.gnome.org/Vala/Tutorial">Vala</link>.

note: (itstool) path: item/p
en: An installed copy of <app>Anjuta</app>.
cs: Nainstalovanou kopii vývojářského studia <app>Anjuta</app>.

note: (itstool) path: section/title
en: Create a project in <app>Anjuta</app>
cs: Vytvoření projektu v IDE <app>Anjuta</app>.

note: (itstool) path: item/p
en: Start <app>Anjuta</app> and click <gui>Create a new project</gui> or <guiseq><gui>File</gui><gui>New</gui><gui>Project</gui></guiseq> to open the project wizard.
cs: Spusťte aplikaci <app>Anjuta</app> a klikněte na  <gui>Vytvořit nový projekt</gui> nebo <guiseq><gui>Soubor</gui> <gui>Nový</gui> <gui>Projekt</gui></guiseq>, aby se otevřel průvodce projektem.

note: (itstool) path: item/p
en: Click on the <gui>Vala</gui> tab and select <gui>GTK+ (Simple)</gui>. Click <gui>Continue</gui>, and fill out your details on the next few pages. Use <file>guitar-tuner</file> as project name and directory.
cs: Na kartě <gui>Vala</gui> zvolte <gui>GTK+ (jednoduchý)</gui>. Klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>guitar-tuner</file>.

note: (itstool) path: item/p
en: Make sure that <gui>Configure external packages</gui> is switched <gui>ON</gui>. On the next page, select <link href="http://valadoc.org/gstreamer-0.10/index.htm"><em>gstreamer-0.10</em></link> from the list to include the GStreamer library in your project. Click <gui>Continue</gui>
cs: Ujistěte se, že <gui>Konfigurovat externí balíčky</gui> je přepnuto na <gui>Zapnuto</gui>. Na následující stránce vyberte v seznamu <link href="http://valadoc.org/gstreamer-0.10/index.htm"><em>gstreamer-0.10</em></link>, aby se knihovna GStreamer zahrnula do vašeho projektu. Klikněte na <gui>Pokračovat</gui>.

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. From the <gui>Project</gui> or <gui>Files</gui> tab, open <file>src/guitar_tuner.vala</file> by double-clicking on it. You should see some code which starts with the lines:
cs: Klikněte na <gui>Použít</gui> a vytvoří se vám projekt. Dvojitým kliknutím na kartě <gui>Projekt</gui> nebo <gui>Soubor</gui> otevřete <file>src/guitar_tuner.vala</file>. Měli byste vidět kód, který začíná řádky:

note: (itstool) path: section/p
en: The code loads an (empty) window from the user interface description file and displays it. More details are given below; you may choose to skip this list if you understand the basics:
cs: Kód načte (prázdné) okno ze souboru s popisem uživatelského rozhraní a zobrazí jej. Dále to podrobněji rozebereme. Pokud jste již pochopili základy, tak tento seznam můžete přeskočit:

note: (itstool) path: item/p
en: The two <code>using</code> lines import namespaces so we don't have to name them explicitly.
cs: Dva řádky <code>using</code> importují jmenné prostory, takže je nebudeme muset výslovně uvádět.

note: (itstool) path: item/p
en: The constructor of the <code>Main</code> class creates a new window by opening a GtkBuilder file (<file>src/guitar-tuner.ui</file>, defined a few lines above), connecting its signals and then displaying it in a window. This GtkBuilder file contains a description of a user interface and all of its elements. You can use Anjuta's editor to design GtkBuilder user interfaces.
cs: Konstruktor třídy <code>Main</code> vytvoří nové okno otevřením souboru GtkBuilder (<file>src/guitar-tuner.ui</file> definovaný a pár řádků dřív), napojí jeho signály a zobrazí jej v okně. Soubor obsahuje popis uživatelského rozhraní a všech jeho prvků. K návrhu uživatelského rozhraní můžete použít editor v IDE Anjuta.

note: (itstool) path: note/p
en: Connecting signals is how you define what happens when you push a button, or when some other event happens. Here, the <code>on_destroy</code> function is called (and quits the app) when you close the window.
cs: Napojení signálu je způsob, jak definovat, co se má stát, když zmáčknete tlačítko nebo se prostě něco přihodí. Zde je zavolána funkce <code>on_destroy</code> (a ukončení aplikace) při zavření okna.

note: (itstool) path: item/p
en: 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).
cs: Statická funkce <code>main</code> se spustí jako výchozí, když spustíte aplikaci napsanou v jazyce Vala. Volá pár funkcí, které vytvoří třídu <code>Main</code> a nastaví a spustí aplikaci. Funkce <code>Gtk.main</code> spustí hlavní smyčku GTK, která spustí uživatelské rozhraní a začne naslouchat událostem (jako je kliknutí nebo zmáčknutí klávesy).

note: (itstool) path: section/p
en: This code is ready to be used, so you can compile it by clicking <guiseq><gui>Build</gui><gui>Build Project</gui></guiseq> (or press <keyseq><key>Shift</key><key>F7</key></keyseq>). When you do this, a dialog will appear. Change the <gui>Configuration</gui> to <gui>Default</gui> and then click <gui>Execute</gui> to configure the build directory. You only need to do this once, for the first build.
cs: Kód je připraven k použití, takže jej můžete zkompilovat kliknutím na <guiseq><gui>Sestavit</gui> <gui>Sestavit projekt</gui></guiseq> (nebo zmáčknutím <keyseq><key>Shift</key> <key>F7</key></keyseq>). Když to uděláte, objeví se dialogové okno. Změňte <gui>Konfiguraci</gui> na <gui>Výchozí</gui> a klikněte na <gui>Spustit</gui>, aby se nakonfigurovala složka, ve které se provádí sestavení. Stačí to udělat jen jednou, pro první sestavení.

note: (itstool) path: section/p
en: A description of the user interface (UI) is contained in the GtkBuilder file <file>src/guitar_tuner.ui</file> defined at the top of the class. To edit the user interface, open <file>src/guitar_tuner.ui</file> by double-clicking on it in the <gui>Project</gui> or <gui>Files</gui> section. This will switch to the interface designer. The design window is in the center; <gui>Widgets</gui> and the widget properties are on the right, and the <gui>Palette</gui> of available widgets is on the left.
cs: Popis uživatelského rozhraní se nachází v souboru GtkBuilder <file>src/guitar_tuner.ui</file> definovaném na začátku třídy. Když chcete uživatelské rozhraní upravit, otevřete <file>src/guitar_tuner.ui</file> dvojitým kliknutím na něj v části <gui>Projekt</gui> nebo <gui>Soubory</gui>. Přepnete se tím do návrháře rozhraní. Navrhované okno je uprostřed, widgety a jejich vlastnosti jsou napravo a paleta dostupných widgetů je nalevo.

note: (itstool) path: section/p
en: The layout of every UI in GTK+ is organized using boxes and tables. Let's use a vertical GtkButtonBox here to assign six GtkButtons, one for each of the six guitar strings.
cs: Rozvržení každého uživatelského rozhraní v GTK+ je provedeno pomocí boxů a mřížek. Zde použijeme svislý <code>GtkButtonBox</code>, do kterého přiřadíme šest <code>GtkButtons</code>, jedno pro každou z kytarových strun.

note: (itstool) path: item/p
en: In the <gui>Palette</gui> tab, from the <gui>Containers</gui> section, select a <gui>Button Box</gui> (GtkButtonBox) by clicking on the icon. Then click on the design window in the center to place it into the window. A dialog will display where you can set the <gui>Number of items</gui> to <input>6</input>. Then click <gui>Create</gui>.
cs: Kliknutím na ikonu vyberte <gui>Box na tlačítka</gui> (GtkButtonBox) z oddílu <gui>Kontejnery</gui> na kartě <gui>Paleta</gui>. Pak kliknutím na návrh okna uprostřed tento box do okna umístěte. Objeví se dialogové okno, kde nastavte <gui>Počet položek</gui> na <input>6</input>. Nakonec klikněte na <gui>Vytvořit</gui>.

note: (itstool) path: note/p
en: You can also change the <gui>Number of elements</gui> and the <gui>Orientation</gui> in the <gui>General</gui> tab on the right.
cs: Můžete také změnit <gui>Počet prvků</gui> a <gui>Orientaci</gui> na kartě <gui>Obecné</gui> napravo.

note: (itstool) path: item/p
en: Now, from the <gui>Control and Display</gui> section of the <gui>Palette</gui> choose a <gui>Button</gui> (GtkButton) by clicking on it. Place it into the first section of the GtkButtonBox by clicking in the first section.
cs: Nyní na <gui>Paletě</gui> v oddílu <gui>Ovládání a zobrazení</gui> vyberte kliknutím <gui>Tlačítko</gui> (GtkButton). Umístěte jej do první části GtkButtonBox kliknutím do této první části.

note: (itstool) path: item/p
en: While the button is still selected, scroll down in the <gui>General</gui> tab on the right to the <gui>Label</gui> property, and change it to <gui>E</gui>. This will be the low E guitar string.
cs: Zatímco je tlačítko stále vybráno, přejděte napravo na kartu <gui>Obecné</gui> na vlastnost <gui>Popisek</gui>a změňte ji na <gui>E</gui>. Bude se jednat o spodní kytarovou strunu E.

note: (itstool) path: note/p
en: The <gui>General</gui> tab is located in the <gui>Widgets</gui> section on the right.
cs: Karta <gui>Obecné</gui> se nachází v části <gui>Widgety</gui> napravo.

note: (itstool) path: item/p
en: Click on the <gui>Signals</gui> tab in the <gui>Widgets</gui> section on the right, and look for the <code>clicked</code> signal of the button. You can use this to connect a signal handler that will be called when the button is clicked by the user. To do this, click on the signal and type <code>main_on_button_clicked</code> in the <gui>Handler</gui> column and press the <key>Enter</key>.
cs: Přepněte se na kartu <gui>Signál</gui> v části <gui>Widgety</gui> napravo a podívejte se po signálu <code>clicked</code> tlačítka. Můžete jej použít k napojení na obsluhu signálu, která bude volána, když uživatel na tlačítko klikne. Provede se to kliknutím na signál a vepsáním <code>main_on_button_clicked</code> do sloupce <gui>Obslužná rutina</gui> a zmáčknutím <key>Enter</key>.

note: (itstool) path: section/p
en: This section will show you how to create the code to produce sounds. <link href="http://developer.gnome.org/platform-overview/stable/gstreamer">GStreamer</link> is GNOME's multimedia framework — you can use it for playing, recording, and processing video, audio, webcam streams and the like. Here, we'll be using it to produce single-frequency tones.
cs: Tato část předvádí, jak vytvořit kód, který vydává zvuk. <link href="http://developer.gnome.org/platform-overview/stable/gstreamer">GStreamer</link> je základní multimediální rámec GNOME. Můžete jej použít k přehrávání, nahrávání a zpracování videa, zvuku, vysílání z webové kamery a podobně. Zde jej použijeme ke generování tónu s jednou frekvencí.

note: (itstool) path: section/p
en: Conceptually, GStreamer works as follows: You create a <link href="http://gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html/section-intro-basics-bins.html"><em>pipeline</em></link> containing several processing elements going from the <em>source</em> to the <em>sink</em> (output). The source can be an image file, a video, or a music file, for example, and the output could be a widget or the soundcard.
cs: Koncepčně GStreamer funguje následovně: Vytvoříte <link href="http://gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html/section-intro-basics-bins.html"><em>rouru</em></link> obsahující různé prvky zpracující směrem od <em>zdroje</em> do <em>cíle</em> (výstupu). Zdrojem může být například soubor s obrázkem, videosoubor nebo hudební soubor, výstupem pak widget nebo zvuková karta.

note: (itstool) path: section/p
en: In this example we will use a tone generator source called <code>audiotestsrc</code> and send the output to the default system sound device, <code>autoaudiosink</code>. We only need to configure the frequency of the tone generator; this is accessible through the <code>freq</code> property of <code>audiotestsrc</code>.
cs: V tomto příkladu použijeme jako zdroj tónový generátor nazývaný <code>audiotestsrc</code> a výstup pošleme do výchozího systémového zvukového zařízení <code>autoaudiosink</code>. Nastavit nám stačí jen frekvenci tónového generátoru. Ta je přístupná v podobě vlastnosti <code>freq</code> u <code>audiotestsrc</code>.

note: (itstool) path: section/p
en: 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:
cs: Musíme přidat řádek inicializující GStreamer. Vložte následující kód na řádek nad volání <code>Gtk.init</code> ve funkci <code>main</code>:

note: (itstool) path: section/p
en: Then, copy the following function into <file>guitar_tuner.vala</file> inside our <code>Main</code> class:
cs: Pak nakopírujte následující funkci do třídy <code>Main</code> v <file>guitar_tuner.vala</file>:

note: (itstool) path: section/code
en: 
    Gst.Element sink;
    Gst.Element source;
    Gst.Pipeline pipeline;
    
    private void play_sound(double frequency)
    {
    	pipeline = new Gst.Pipeline ("note");
    	source   = Gst.ElementFactory.make ("audiotestsrc",
    	                                    "source");
    	sink     = Gst.ElementFactory.make ("autoaudiosink",
    	                                    "output");
    
    	/* set frequency */
    	source.set ("freq", frequency);
    
    	pipeline.add (source);
    	pipeline.add (sink);
    	source.link (sink);
    
    	pipeline.set_state (Gst.State.PLAYING);
    
    	/* stop it after 200ms */
    	var time = new TimeoutSource(200);
    
    	time.set_callback(() =&gt; {
    		pipeline.set_state (Gst.State.NULL);
    		return false;
    	});
    	time.attach(null);
    }
cs: 
    Gst.Element sink;
    Gst.Element source;
    Gst.Pipeline pipeline;
    
    private void play_sound(double frequency)
    {
    	pipeline = new Gst.Pipeline ("note");
    	source   = Gst.ElementFactory.make ("audiotestsrc",
    	                                    "source");
    	sink     = Gst.ElementFactory.make ("autoaudiosink",
    	                                    "output");
    
    	/* nastavení frekvence */
    	source.set ("freq", frequency);
    
    	pipeline.add (source);
    	pipeline.add (sink);
    	source.link (sink);
    
    	pipeline.set_state (Gst.State.PLAYING);
    
    	/* zastavení po 200 ms */
    	var time = new TimeoutSource(200);
    
    	time.set_callback(() =&gt; {
    		pipeline.set_state (Gst.State.NULL);
    		return false;
    	});
    	time.attach(null);
    }

note: (itstool) path: item/p
en: The first three lines create source and sink GStreamer elements (<link href="http://valadoc.org/gstreamer-0.10/Gst.Element.html"><code>Gst.Element</code></link>), and a <link href="http://valadoc.org/gstreamer-0.10/Gst.Pipeline.html">pipeline element</link> (which will be used as a container for the other two elements). Those are class variables so they are defined outside the method. The pipeline is given the name "note"; the source is named "source" and is set to the <code>audiotestsrc</code> source; and the sink is named "output" and set to the <code>autoaudiosink</code> sink (default sound card output).
cs: Prvních tři řádky vytvoří prvky GStreamer typu zdroj a cíl (<link href="http://valadoc.org/gstreamer-0.10/Gst.Element.html"><code>Gst.Element</code></link>) a <link href="http://valadoc.org/gstreamer-0.10/Gst.Pipeline.html">prvek typu roura</link> (který bude použit jako kontejner pro první dva prvky). Jedná se o proměnné třídy, takže jsou definovny mimo metodu. Roura dostane název „note“. Zdroj je pojmenován „source“ a je nastaven jako <code>audiotestsrc</code>. Cíl je pojmenován „output“ a je nastaven jako <code>autoaudiosink</code> (výchozí výstup zvukové karty).

note: (itstool) path: item/p
en: The call to <link href="http://valadoc.org/gobject-2.0/GLib.Object.set.html"><code>source.set</code></link> sets the <code>freq</code> property of the source element to <code>frequency</code>, which is passed in as an argument to the <code>play_sound</code> function. This is just the frequency of the note in Hertz; some useful frequencies will be defined later on.
cs: Volání <link href="http://valadoc.org/gobject-2.0/GLib.Object.set.html"><code>source.set_property</code></link> nastaví vlastnost <code>freq</code> prvku <code>source</code> na frekvenci <code>frequency</code>, která je předána jako argument do funkce <code>play_sound</code>. Jedná se o frekvenci v Hertzích. Správné frekvence nadefinujeme později.

note: (itstool) path: item/p
en: <link href="http://valadoc.org/gstreamer-0.10/Gst.Bin.add.html"><code>pipeline.add</code></link> puts the source and sink into the pipeline. The pipeline is a <link href="http://valadoc.org/gstreamer-0.10/Gst.Bin.html"><code>Gst.Bin</code></link>, which is just an element that can contain multiple other GStreamer elements. In general, you can add as many elements as you like to the pipeline by adding more calls to <code>pipeline.add</code>.
cs: <link href="http://valadoc.org/gstreamer-0.10/Gst.Bin.add.html"><code>pipeline.add</code></link> vloží zdroj a cíl do roury. Roura je <link href="http://valadoc.org/gstreamer-0.10/Gst.Bin.html"><code>Gst.Bin</code></link>, což je zase jen prvek, který může obsahovat více dalších prvků GStreamer. Obecně můžete přidat tolik prvků, kolik chcete, pomocí opakovaného volání <code>pipeline.add</code>.

note: (itstool) path: item/p
en: Next, <link href="http://valadoc.org/gstreamer-0.10/Gst.Element.link.html"><code>sink.link</code></link> is used to connect the elements together, so the output of source (a tone) goes into the input of sink (which is then output to the sound card). <link href="http://www.valadoc.org/gstreamer-0.10/Gst.Element.set_state.html"><code>pipeline.set_state</code></link> is then used to start playback, by setting the <link href="http://www.valadoc.org/gstreamer-0.10/Gst.State.html">state of the pipeline</link> to playing (<code>Gst.State.PLAYING</code>).
cs: Následně je <link href="http://valadoc.org/gstreamer-0.10/Gst.Element.link.html"><code>sink.link</code></link> použito k propojení prvků navzájem, takže výstup prvku <code>source</code> (tón) putuje do vstupu prvku <code>sink</code> (což je výstup do zvukové karty). <link href="http://www.valadoc.org/gstreamer-0.10/Gst.Element.set_state.html"><code>pipeline.set_state</code></link> je použito ke spuštění přehrávání nastavením <link href="http://www.valadoc.org/gstreamer-0.10/Gst.State.html">stavu roury</link> na přehrávání (<code>Gst.State.PLAYING</code>).

note: (itstool) path: item/p
en: We don't want to play an annoying tone forever, so the last thing <code>play_sound</code> does is to add a <link href="http://www.valadoc.org/glib-2.0/GLib.TimeoutSource.html"><code>TimeoutSource</code></link>. This sets a timeout for stopping the sound; it waits for 200 milliseconds before calling a signal handler defined inline that stops and destroys the pipeline. It returns <code>false</code> to remove itself from the timeout, otherwise it would continue to be called every 200 ms.
cs: Nechceme ale hrát nějaký tón navždycky, takže poslední věcí, kterou <code>play_sound</code> udělá, je že přidá <link href="http://www.valadoc.org/glib-2.0/GLib.TimeoutSource.html"><code>TimeoutSource</code></link>. Tím se nastaví časový limit pro zastavení zvuku. Čeká 200 milisekund a pak zavolá obsluhu signálu definovanou jako vloženou, která zastaví a zlikviduje rouru. Ta vrací <code>false</code>, aby odstranila sebe sama z <code>TimeoutSource</code>, jinak by se pokračovalo v jejím volání každých 200 ms.

note: (itstool) path: section/p
en: 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.
cs: V návrháři uživatelského rozhraní to můžete udělat tak, že všechna tlačítka budou, když se na ně klikne, volat stejnou funkci <gui>on_button_clicked</gui>. Ve skutečnosti napíšeme <gui>main_on_button_clicked</gui>, což návrháři říká, že tato metoda je součástí <gui>Main</gui>. Tuto funkci musíme přidat do souboru se zdrojovým kódem.

note: (itstool) path: section/p
en: To do this, in the user interface file (guitar_tuner.ui) select one of the buttons by clicking on it, then open <file>guitar_tuner.vala</file> (by clicking on the tab in the center). Switch to the <gui>Signals</gui> tab on the right, which you used to set the signal name. Now take the row where you set the <gui>clicked</gui> signal and drag and drop it into to the source file at the beginning of the class. The following code will be added to your source file:
cs: K tomuto účelu vyberte v souboru s uživatelským rozhraním (guitar_tuner.ui) kliknutím jedno z tlačítek a pak otevřete <file>guitar_tuner.vala</file> (kliknutím na kartu uprostřed). Přepněte se na kartu <gui>Signály</gui> napravo, kterou jste již použili pro nastavení názvu signálu. Nyní chytněte řádek, na kterém jste nastavili signál <gui>clicked</gui> a přetáhněte jej do zdrojového kódu na začátek třídy. Do zdrojového kódu se přidá následující kód:

note: (itstool) path: section/code
en: 
    public void on_button_clicked (Gtk.Button sender) {
    
    }
cs: 
    public void on_button_clicked (Gtk.Button odesilatel) {
    
    }

note: (itstool) path: note/p
en: You can also just type the code at the beginning of the class instead of using the drag and drop.
cs: Místo přetahování z návrháře můžete kód samozřejmě také napsat ručně na začátek třídy.

note: (itstool) path: section/p
en: This signal handler has only one argument: the <link href="http://valadoc.org/gtk+-3.0/Gtk.Widget.html"><code>Gtk.Widget</code></link> that called the function (in our case, always a <link href="http://valadoc.org/gtk+-3.0/Gtk.Button.html"><code>Gtk.Button</code></link>).
cs: Tato obsluha signálu má jen jeden argument: <link href="http://valadoc.org/gtk+-3.0/Gtk.Widget.html"><code>Gtk.Widget</code></link>, který je volán funkcí (v našem případě vždy <link href="http://valadoc.org/gtk+-3.0/Gtk.Button.html"><code>Gtk.Button</code></link>).

note: (itstool) path: section/title
en: Define the signal handler
cs: Definování obsluhy signálů

note: (itstool) path: section/p
en: We want to play the correct sound when the user clicks a button. For this, we flesh out the signal handler which we defined above, <code>on_button_clicked</code>. We could have connected every button to a different signal handler, but that would lead to a lot of code duplication. Instead, we can use the label of the button to figure out which button was clicked:
cs: Když uživatel klikne na tlačítko, chceme přehrát správný zvuk. To znamená, že musíme oživit obsluhu signálu  <code>on_button_clicked</code>, kterou jsem zadeklarovali již dříve. Mohli bychom mít napojená všechna tlačítka na různé obslužné funkce, ale to by vedlo ke zbytečné duplicitě kódu. Místo toho použijeme popisek každého z tlačítek ke zjištění, na které tlačítko bylo kliknuto:

note: (itstool) path: section/p
en: 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>.
cs: Tlačítko <code>Gtk.Button</code>, na které bylo kliknuto, je předáno jako argument (<code>odesilatel</code>) do <code>on_button_clicked</code>. Pomocí <code>get_child</code> můžeme získat popisek tohoto tlačítka a z něj následně získat jeho text pomocí <code>get_label</code>.

note: (itstool) path: section/p
en: 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!
cs: Výraz <code>switch</code> porovnává text popisku s notami, které chceme zahrát a funkce <code>play_sound</code> je zavolána s příslušnou frekvencí pro tuto notu. Tím se přehraje tón – máme funkční kytarovou ladičku!

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="guitar-tuner/guitar-tuner.vala">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="guitar-tuner/guitar-tuner.vala">ukázkovým kódem</link>.

note: (itstool) path: section/title
en: Further reading
cs: Co dalšího si přečíst

note: (itstool) path: section/p
en: To find out more about the Vala programming language you might want to check out the <link href="http://live.gnome.org/Vala/Tutorial">Vala Tutorial</link> and the <link href="http://valadoc.org/">Vala API Documentation</link>
cs: Jestli si chcete najít více o programování v jazyce Vala, můžete se podívat na <link href="http://live.gnome.org/Vala/Tutorial">Výuku jazyka Vala</link> a <link href="http://valadoc.org/">Dokumentaci k API jazyka Vala</link>.

note: (itstool) path: info/desc
en: Your first GNOME application!
cs: Vaše první aplikace pro GNOME!

note: (itstool) path: page/title
en: 1. Hello, GNOME!
cs: 1. Ahoj GNOME!

note: (itstool) path: synopsis/p
en: This tutorial will show you how to write your first GNOME application in JavaScript. You will use JavaScript to write for GNOME the same way you would for the web. Afterwards, you will learn how to use "native" widgets, to write applications that look and feel like other GNOME apps.
cs: V této lekci si ukážeme, jak napsat vaši první aplikaci pro GNOME v jazyce JavaScript. Použijeme jej k psaní pro GNOME stejným způsobem, jako byste použili pro web. Poté se dozvíte, jako použít nativní widgety k napsaní aplikace, která už bude vypadat jako správná aplikace GNOME.

note: (itstool) path: note/p
en: Have you gotten GNOME installed on your computer, and <link xref="set-up-gedit.js">gedit</link> set up to write code with? You'll want to do these things first.
cs: Máte v počítači nainstalováno GNOME a textový editor <link xref="set-up-gedit.js">gedit</link> pro psaní kódu? To jsou věci, které pro začátek potřebujeme.

note: (itstool) path: section/title
en: Let's start with a web page
cs: Začněme s webovou stránkou

note: (itstool) path: section/p
en: Here's some basic HTML, CSS, and JavaScript code. Does this look familiar?
cs: Zde je nějaký základní kód používající HTML, CSS a JavaScript. Přijde vám to povědomé?

note: (itstool) path: section/code
en: 
    &lt;!DOCTYPE html&gt;
    &lt;html&gt;
        &lt;head&gt;
            &lt;meta charset="utf-8"&gt;
            &lt;title&gt;Hello, GNOME!&lt;/title&gt;
    
            &lt;!-- Use JavaScript to show a greeting when someone clicks the button --&gt;
            &lt;script type="application/javascript"&gt;
            function greeting () {
                document.getElementById ("greeting").innerHTML = ("O hai!");
            }
            &lt;/script&gt;
    
            &lt;!-- Very basic CSS style using the GNOME font --&gt;
            &lt;style type="text/css"&gt;
                body {
                    font-face: Cantarell, sans-serif;
                    text-align: center; }
            &lt;/style&gt;
    
        &lt;/head&gt;
        &lt;body&gt;
            &lt;br /&gt; &lt;br /&gt;
            &lt;button type="button" onclick="greeting()"&gt;Hello, GNOME!&lt;/button&gt;
    
            &lt;!-- Empty H1 element gets filled in when the button is clicked --&gt;
            &lt;h1 id="greeting"&gt;&lt;/h1&gt;
        &lt;/body&gt;
    &lt;/html&gt;
cs: 
    &lt;!DOCTYPE html&gt;
    &lt;html&gt;
        &lt;head&gt;
            &lt;meta charset="utf-8"&gt;
            &lt;title&gt;Hello, GNOME!&lt;/title&gt;
    
            &lt;!-- Použije JavaScript k zobrazení uvítání, když se klikne na tlačítko --&gt;
            &lt;script type="application/javascript"&gt;
            function greeting () {
                document.getElementById ("greeting").innerHTML = ("O hai!");
            }
            &lt;/script&gt;
    
            &lt;!-- Velmi základní styl CSS používající písmo z GNOME --&gt;
            &lt;style type="text/css"&gt;
                body {
                    font-face: Cantarell, sans-serif;
                    text-align: center; }
            &lt;/style&gt;
    
        &lt;/head&gt;
        &lt;body&gt;
            &lt;br /&gt; &lt;br /&gt;
            &lt;button type="button" onclick="greeting()"&gt;Hello, GNOME!&lt;/button&gt;
    
            &lt;!-- Prázdný prvek H1, bude vyplněn po kliknutí na tlačítko --&gt;
            &lt;h1 id="greeting"&gt;&lt;/h1&gt;
        &lt;/body&gt;
    &lt;/html&gt;

note: (itstool) path: section/p
en: Let's save this as <file>hellognome.html</file>, and see what it looks like when we run it!
cs: Pojďme jej uložit do <file>hellognome.html</file> a podívat se, jak to bude vypadat, když jej spustíme!

note: (itstool) path: section/p
en: You <em>can</em> run the above code by opening <file>hellognome.html</file> in a web browser. But here, we're going to create a GNOME application that runs our web app inside of it, just like you see in the screenshot. You'll be able to resize and maximize the window, and click the X in the corner to close it, just like you'd expect from any other GNOME app. The difference is that this one will run our web code inside of it.
cs: Kód uvedený výše <em>můžete</em> spustit otevřením <file>hellognome.html</file> ve webovém prohlížeči. My se ale chystáme vytvořit aplikaci pro GNOME, která spustí naši webovou aplikaci uvnitř sebe tak, jak tom můžete vidět na snímku obrazovky. Budete moci měnit velikost okna a maximalizovat jej, kliknout na <gui>×</gui> v rohu, aby se zavřelo, prostě vše tak, jak to očekáváte od aplikace GNOME. Rozdíl je v tom, že ta naše spustí uvnitř sebe naši webovou aplikaci.

note: (itstool) path: section/p
en: The best part? We're going to continue to use JavaScript, to write all the parts that make our app work with GNOME. Let's look at the code, and see how it's done!
cs: A co je na tom nejlepší? Hodláme pokračovat v použití jazyka JavaScript k napsání všech zbývajících částí naší aplikace, aby pracovala v GNOME. Pojďme se podívat na kód, ať víte jak na to!

note: (itstool) path: section/title
en: Creating a GNOME window to frame our web app
cs: Vytvoření okna GNOME, které pojme naši webovou aplikaci

note: (itstool) path: section/p
en: First, we need to tell GNOME that this is a JavaScript application, which uses gjs. Gjs is GNOME's way of turning your JavaScript code into instructions it understands, so this line always has to go at the start of your applications.
cs: Nejprve musíme GNOME říct, že tato aplikace je v jazyce JavaScript, k čemuž použijeme gjs. Gjs je v GNOME způsob, jak přeměnit váš kód v jazyce JavaScript na instrukce, kterým rozumí, takže tento řádek musí být vždy na začátku vaší aplikace.

note: (itstool) path: section/p
en: Then we should set the versions of the libraries we'll be using.
cs: Následně bychom měli nastavit verze knihoven, které se budou používat.

note: (itstool) path: section/p
en: After that, we need to tell GNOME which libraries we want to import.
cs: Dále potřebujeme říci GNOME, které knihovny chceme importovat.

note: (itstool) path: section/p
en: Just like how add-on libraries like jQuery let us do extra things with JavaScript, each of these libraries gives us new capabilities for our GNOME apps:
cs: Podobně, jako přidání knihoven, jako je jQuery, která umožňuje v jazyce JavaScript provádět nové věci, každá z těchto knihoven nám poskytne schopnosti pro naši aplikaci GNOME:

note: (itstool) path: item/p
en: <file>Gtk</file> is the basic part of any GNOME application, which lets you create windows and widgets and tie them together.
cs: <file>Gtk</file> je základní části kterékoliv aplikace GNOME, které vám umožní vytvořit okna a widgety a spojit je dohromady.

note: (itstool) path: item/p
en: <file>GLib</file> is a helper library, which lets us do things like tell GNOME where the <file>hellognome.html</file> file we created is.
cs: <file>GLib</file> je pomocná knihovna, díky kterém můžeme dělat takové věci, jako říci GNOME, kde je soubor <file>hellognome.html</file>, který jsme vytvořili.

note: (itstool) path: item/p
en: And <file>Webkit</file> is a web rendering engine, which we'll use to basically create a browser window to open our HTML file with.
cs: <file>Webkit</file> je webové vykreslovací jádro, které použijeme v podstatě k vytvoření okna prohlížeče, ve kterém otevřeme náš soubor HTML.

note: (itstool) path: section/p
en: Now we create the application itself:
cs: Nyní vytvoříme vlastní aplikaci:

note: (itstool) path: section/p
en: This will look familiar to you if you've worked with object-oriented JavaScript before. That's right; our whole application is a class called HelloGNOME.
cs: Pokud jste již dříve pracovali s objektově orientovaným jazykem JavaScript, přijde vám to známe. Máte pravdu, celá naše aplikace je třída nazvaná HelloGNOME.

note: (itstool) path: section/code
en: 
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application();
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
cs: 
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application();
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazující okno při aktivaci
        _onActivate: function () {
            this._window.present ();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function () {
            this._buildUI ();
        }

note: (itstool) path: section/p
en: Here's some code you will more or less copy-and-paste for every JavaScript application you build. It creates a new Application, and then binds its activate and startup signals to functions that make the window show itself and build its user interface, respectively.
cs: Zde je nějaký kód, který více méně zkopírujte do každé aplikace v jazyce JavaScript, kterou budete tvořit. Vytvoří novou aplikaci a napojí její signály <code>"activate"</code> a <code>"startup"</code> na funkce, které zajistí, že okno zobrazí sebe samo a sestaví své uživatelské rozhraní.

note: (itstool) path: section/p
en: What does that mean? Well, everything in a GNOME application sends out a signal when something important happens. A button might send out the clicked signal when you click on it, for instance. Our job is to connect the signals to functions which handle them, and make the things that we want to have happen occur. We do this using each object's connect method, which takes two arguments: The signal we want to handle, and the bound function, which we have to use to tell connect which function we want to have handle the signal.
cs: Co to znamená? V aplikacích GNOME vše posílá signály pokaždé, když se něco zajímavého stane. Například tlačítko může poslat signál <code>"clicked"</code>, když je na něj kliknuto. Našim úkolem je napojit signály na funkce, které je zpracují a provedou něco, co chceme, aby se stalo. To uděláme použitím metody <code>connect</code> u každého objektu. Tato metoda má dva argumenty: Signál, který chceme obsluhovat, a vazební funkci, což je funkce, po které chceme, aby signál obsluhovala.

note: (itstool) path: section/p
en: In this case, we want _onActivate to handle the activate signal, and _onStartup to handle the startup signal. _onActivate just tells the window to present itself; so basically, whenever you <keyseq><key>Alt</key> <key>Tab</key></keyseq> to the application it appears, like you would expect it to. _onStartup calls _buildUI, which is the function that creates our user interface and is the next part that we will look at.
cs: V tomto případě chceme, aby <code>_onActivate</code> obsluhovala signál <code>"activate"</code> a <code>_onStartup</code> signál <code>"startup"</code>. Funkce <code>_onActivate</code> akorát řekne oknu, aby se zobrazilo. Takže v podstatě, kdykoliv zmáčknete <keyseq><key>Alt</key> <key>Tab</key></keyseq>, aplikace se objeví tak, jak očekáváte. Funkce <code>_onStartup</code> volá funkci <code>_buildUI</code>, která vytvoří naše uživatelské rozhraní a je následující částí, na kterou se podíváme.

note: (itstool) path: note/p
en: When you copy and paste the above code for your own applications, be sure to change the class name to a unique one each time.
cs: Když si kód uvedený výše zkopírujete a vložíte pro svoji vlastní aplikaci, přidělte třídě pokaždé jedinečný název.

note: (itstool) path: section/title
en: Designing our window's UI
cs: Návrh uživatelského rozhraní našeho okna

note: (itstool) path: section/p
en: In the _buildUI function, we're going to tell GNOME about our window and the things inside it, one at a time. After that, we're going to connect everything together and put it all on display.
cs: Ve funkci <code>_buildUI</code> se chystáme postupně říci GNOME o našem okně a věcech uvnitř něj. Nakonec vše spojíme dohromady a zobrazíme.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                title: "Welcome to GNOME",
                default_height: 200,
                default_width: 400,
                window_position: Gtk.WindowPosition.CENTER });
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                title: "Welcome to GNOME",
                default_height: 200,
                default_width: 400,
                window_position: Gtk.WindowPosition.CENTER });

note: (itstool) path: section/p
en: The first object we create is an ApplicationWindow. It needs a title to go in the title bar, and its application property needs to be the application that we created, above. Beyond that, there are various ways of customizing how it looks, which the <link xref="GtkApplicationWindow.js">ApplicationWindow</link> reference page will go into more detail about. As you can see here, we gave it a default height and width (measured in pixels), and told GNOME we want our window to appear in the center of the screen.
cs: První objekt, který vytvoříme, je <code>ApplicationWindow</code>. To potřebuje název do záhlaví a jeho vlastnost <code>application</code> musí být aplikace, kterou jsem vytvořili v předchozím. Mimo to, existují různé způsoby, jak si přizpůsobit jeho vzhled, v čemž jde více do podrobností stránka věnovaná widgetu <link xref="GtkApplicationWindow.js">ApplicationWindow</link>. Jak můžete vidět zde, dáli jsme mu výchozí výšku a šířku (měřenou v pixelech) a řekli GNOME, že chceme, aby se naše okno objevilo uprostřed obrazovky.

note: (itstool) path: section/code
en: 
            // Create a webview to show the web app
            this._webView = new Webkit.WebView ();
    
            // Put the web app into the webview
            this._webView.load_uri (GLib.filename_to_uri (GLib.get_current_dir() +
                "/hellognome.html", null));
cs: 
            // Vytvoří webové zobrazení pro zobrazení webové aplikace
            this._webView = new Webkit.WebView ();
    
            // Vloží webovou aplikaci do webového zobrazení
            this._webView.load_uri (GLib.filename_to_uri (GLib.get_current_dir() +
                "/hellognome.html", null));

note: (itstool) path: section/p
en: Remember how we imported Webkit right at the start? Here we're creating a new instance of a Webkit class called a WebView, which is more or less a browser window you can put inside of your app. After that, we then give it the URI that we want it to load when the application starts up.
cs: Pamatujete, jak jsme na začátku správně importovali Webkit? Zde vytváříme novu instanci třídy <code>Webkit</code> nazvanou <code>WebView</code>, což je více méně okno webového prohlížeče, které můžete vložit dovnitř své aplikace. Po té mu předáme adresu URI, kterou chceme načíst při spuštění aplikace.

note: (itstool) path: section/p
en: We <em>could</em> just give it a web URI, like <link href="http://gnome.org">http://gnome.org</link>. Instead, here we use a couple of GLib helper functions to tell the WebView where our <file>hellognome.html</file> file is. GLib.get_current_dir returns the directory that our app's running in, and GLib.filename_to_uri turns our file's path and filename into a URI that the WebView's load_uri function understands. (filename_to_uri's second parameter should be null unless you know what it's used for and have a reason for changing it.)
cs: <em>Mohli</em> bychom mu prostě předat webovou URI, jako je <link href="http://gnome.org">http://gnome.org</link>. Místo toho zde použijeme pár pomocných funkcí z GLib, abychom widgetu <code>WebView</code> řekli, kde náš soubor <file>hellognome.html</file> je. <code>GLib.get_current_dir</code> vrací složku, ve které naše aplikace běží a <code>GLib.filename_to_uri</code> vrací cestu k našemu souboru a jeho název v podobě adresy URI, které rozumí funkce <code>load_uri</code> widgetu <code>WebView</code>. (Druhý parametr funkce <code>filename_to_uri</code> by měl být <code>null</code>, ledaže víte, k čemu slouží a máte důvod jej změnit.)

note: (itstool) path: section/code
en: 
            // Put the webview into the window
            this._window.add (this._webView);
    
            // Show the window and all child widgets
            this._window.show_all();
        },
    
    });
cs: 
            // Vloží webové zobrazení do okna
            this._window.add (this._webView);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        },
    
    });

note: (itstool) path: section/p
en: Each window can hold one, and only one, widget. Normally, we'd use a container widget like a <link xref="grid.js">Grid</link> to put multiple widgets into, then use the window's add function to add the Grid to it. Here, we just need the WebView, so that's all we add to the window. After that, as the last part of the _buildUI function that creates our window, we tell the window to show itself and its contents.
cs: Každé okno může obsahovat jeden a právě jeden widget. Normálně bychom použili kontejnerový widget, jako je <link xref="grid.js">Grid</link>, abychom do něj vložili více widgetů a následně použili funkci <code>add</code> okna k jeho vložení do okna. V tomto případě ale potřebujeme jen jediný widget <code>WebView</code>, takže jej můžeme přidat do okna přímo. Po té, jako poslední část funkce <code>_buildUI</code>, která vytváří naše okno, řekneme oknu, aby zobrazilo sebe a svůj obsah.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new HelloGNOME ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new HelloGNOME ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of our HelloGNOME class, and tell GNOME to run it.
cs: Nakonec vytvoříme novou instanci naší třídy HelloGNOME a řekneme GNOME, aby ji spustil.

note: (itstool) path: section/title
en: Running your GNOME application
cs: Spuštění vaší aplikace pro GNOME

note: (itstool) path: section/p
en: Now that we've created our first GNOME application, it's time to test it out! You don't need to compile your app or install any special software for this; GNOME has gjs built in, to let it run GNOME Shell. Just save <file>hellognome.html</file> and our actual application, <file>hellognome.js</file>, to a directory you can get to with the terminal. (They usually open onto your home directory, the one that's called by your username.) After that, open a terminal, go there, and type:
cs: Nyní máme vytvořenou vaši první aplikace pro GNOME a je čas ji otestovat! Nepotřebujete ji kompilovat ani pro ni instalovat nějaký speciální software. GNOME má gjs vestavěné, aby fungoval GNOME Shell. Takže akorát uložte <file>hellognome.html</file> a skutečnou aplikaci <file>hellognome.js</file> do složky, ke které se dostanete v terminálu. (Obvykle do vaší domovské složky, která má název podle vašeho uživatelského jména.) Pak otevřete terminál, přejděte do ní a napište:

note: (itstool) path: section/p
en: You should see more or less the same screenshot as before, with a button that you can click to make a short message appear.
cs: Měli byste vidět víceméně to stejné, co na snímku obrazovky výše, s tlačítkem, které po kliknutí zobrazí krátkou zprávu.

note: (itstool) path: note/p
en: You can use the terminal command
cs: Můžete použít terminálový příkaz

note: (itstool) path: note/screen
en:  <output style="prompt">$ </output>cd <var>(directory name)</var>
cs:  <output style="prompt">$ </output>cd <var>(název složky)</var>

note: (itstool) path: note/p
en: to navigate between directories inside the Terminal, in order to get to where you saved the files. There is also an extension for Nautilus, GNOME's file manager, which lets you right-click anywhere inside it to open a terminal window right there. Check the app you use to install new software (like Add/Remove Programs or the Software Center) for it.
cs: k pohybu mezi složkami v terminálu, abyste se dostali do složky, kde máte soubory uložené. Existuje i rozšíření pro Nautilus, což je správce souborů v GNOME, které umožňuje kliknout pravým tlačítkem v kterékoliv složce a otevřít v ní terminálové okno. Podívejte se po tomto rozšíření v aplikaci, kterou používáte k instalaci nového softwaru (jako je „Přidat/Odebrat programy“ nebo „Centrum softwaru“).

note: (itstool) path: section/p
en: <link xref="02_welcome_to_the_grid.js">Continue on to the next tutorial</link> to learn how to build "native" GNOME applications that look and feel like the others, instead of a webview with HTML code inside. Or take a look at some <link xref="beginner.js#samples">code samples</link>, if you'd like to see example code for each Gtk widget.
cs: <link xref="02_welcome_to_the_grid.js">Pokračujte na následující lekci</link>, ve které se dozvíte, jak místo webového zobrazení s kódem HTML vytvořit „nativní“ aplikaci pro GNOME, která bude vypadat jako ostatní aplikace a zapadat do prostředí. Nebo se podívejte na některé <link xref="beginner.js#samples">ukázky kódu</link>, pokud byste chtěli vidět kód pro jednotlivé widgety Gtk.

note: (itstool) path: section/p
en: Finally, if you want to just build GNOME applications using JavaScript libraries designed for the web, you can basically stop here and go do that! Check out <link xref="beginner.js#tutorials">the later tutorials</link> if you'd like to see how to create a .desktop file for your application, which will let it appear in your desktop's Activities menu with all your other apps.
cs: A konečně, jestli jen chcete vytvářet aplikace pro GNOME pomocí knihoven jazyka JavaScript navržených pro web, můžete zde skončit se čtením a jít na to. Podívejte se do <link xref="beginner.js#tutorials">dalších lekcí</link>, pokud byste pro vaši aplikaci rádi vytvořili soubor .desktop, díky němuž se vaše aplikace objeví mezi dalšími aplikacemi v nabídce pracovní plochy <gui>Činnosti</gui>.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    imports.gi.versions.WebKit2 = '4.0';
    
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    const Webkit = imports.gi.WebKit2;
    
    class HelloGNOME {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application ();
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                title: "Welcome to GNOME",
                default_height: 200,
                default_width: 400,
                window_position: Gtk.WindowPosition.CENTER });
    
            // Create a webview to show the web app
            this._webView = new Webkit.WebView ();
    
            // Put the web app into the webview
            this._webView.load_uri (GLib.filename_to_uri (GLib.get_current_dir() +
                "/hellognome.html", null));
    
            // Put the webview into the window
            this._window.add (this._webView);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
    };
    
    // Run the application
    let app = new HelloGNOME ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    imports.gi.versions.WebKit2 = '4.0';
    
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    const Webkit = imports.gi.WebKit;
    
    class HelloGNOME {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application ();
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazující okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                title: "Welcome to GNOME",
                default_height: 200,
                default_width: 400,
                window_position: Gtk.WindowPosition.CENTER });
    
            // Vytvoří webové zobrazení pro zobrazení webové aplikace
            this._webView = new Webkit.WebView ();
    
            // Vloží webovou aplikaci do webového zobrazení
            this._webView.load_uri (GLib.filename_to_uri (GLib.get_current_dir() +
                "/hellognome.html", null));
    
            // Vloží webové zobrazení do okna
            this._window.add (this._webView);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
    };
    
    // Spustí aplikaci
    let app = new HelloGNOME ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: Creating a small "Hello, World" application using GTK+.
cs: Vytvoření malé aplikace „Hello, World“ pomocí GTK+.

note: (itstool) path: note/p
en: For a detailed walk-through of creating a GTK+ dialog in C, see <link href="https://developer.gnome.org/gtk3/stable/gtk-getting-started.html">Getting Started with GTK+</link>
cs: Podrobného průvodce vytvářením dialogového okna GTK+ v jazyce C najdete v <link href="https://developer.gnome.org/gtk3/stable/gtk-getting-started.html">Začínáme s GTK+</link>.

note: (itstool) path: page/p
en: Writing a hello world GTK+ dialog in C can be done as seen in the code sample below:
cs: Dialogové okno „Hello, World“ je možné v jazyce C napsat tak, jak můžete vidět v ukázkovém kódu níže:

note: (itstool) path: page/p
en: GtkApplication initializes GTK+. It also connects the <gui>x</gui> button that's automatically generated along with the window to the "destroy" signal. We can start building our first window. We do this by creating a variable called <var>window</var> and assigning it a gtk_application_window_new. The window title can be any string you want it to be. To be on the safe side, it's best to stick to UTF-8 encoding. The code above will create a dialog window similar to what can be seen below:
cs: <code>GtkApplication</code> inicializuje GTK+. Rovněž napojí tlačítko <gui>×</gui>, které je automaticky vygenerováno spolu s oknem, na signál <code>"destroy"</code>. Můžeme začít budovat naši první aplikaci. Začneme vytvořením proměnné nazvané <var>windows</var>, do které přiřadíme <code>gtk_application_window_new</code>. Název okna může být libovolný řetězec, ale je bezpečnější, když použijete kódování UTF-8. Kód výše vytvoří dialogové okno podobné tomu, co vidíte níže:

note: (itstool) path: info/desc
en: A basic "hello, world" application
cs: Základní aplikace „Hello, world“

note: (itstool) path: page/title
en: How to build, install and create a <file>tar.xz</file> of a Hello World program
cs: Jak sestavit a nainstalovat program „Hello World“ a jak pro něj vytvořit balíček <file>tar.xz</file>

note: (itstool) path: synopsis/p
en: This tutorial will demonstrate how to:
cs: Tato lekce ukazuje jak:

note: (itstool) path: item/p
en: create a small "Hello, World" application using JavaScript and GTK+
cs: vytvořit malou aplikaci „Hello, World“ pomocí jazyka JavaScript a GTK+

note: (itstool) path: item/p
en: make the <file>.desktop</file> file
cs: vytvořit soubor <file>.desktop</file>

note: (itstool) path: item/p
en: how to set up the build system
cs: nastavit sestavovací systém

note: (itstool) path: section/title
en: Create the program
cs: Vytvoření programu

note: (itstool) path: section/p
en: This needs to be the first line of your script:
cs: Jako první řádek vašeho skriptu musí být:

note: (itstool) path: section/p
en: It tells the script to use <link href="https://live.gnome.org/Gjs/">Gjs</link>. Gjs is a JavaScript binding for GNOME.
cs: Tím se vašemu skriptu říká, že má použít <link href="https://live.gnome.org/Gjs/">Gjs</link>. Gjs je vazba jazyka JavaScript na GNOME.

note: (itstool) path: section/p
en: In order for our script to work with GNOME, we need to import GNOME libraries via GObject Introspection. Here we import the language bindings and GTK+, the library which contains the graphical widgets used to make GNOME applications.
cs: Aby náš skript fungoval s GNOME, musíme naimportovat knihovny GNOME přes GObject Introspection. Zde importujeme vazbu jazyka a GTK+, tj. knihovnu, která obsahuje grafické widgety používané k vytvoření aplikací GNOME.

note: (itstool) path: section/code
en: const Application = new Lang.Class({
        //A Class requires an explicit Name parameter. This is the Class Name.
        Name: 'Application',
    
        //create the application
        _init: function() {
            this.application = new Gtk.Application();
    
           //connect to 'activate' and 'startup' signals to handlers.
           this.application.connect('activate', Lang.bind(this, this._onActivate));
           this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        //create the UI
        _buildUI: function() {
            this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                       title: "Hello World!" });
        },
    
        //handler for 'activate' signal
        _onActivate: function() {
            //show the window and all child widgets
            this._window.show_all();
        },
    
        //handler for 'startup' signal
        _onStartup: function() {
            this._buildUI();
        }
    });
cs: const Application = new Lang.Class({
        // Třída vyžaduje výslovné nastavení vlastnosti Name. Jedná se o název třídy.
        Name: 'Application',
    
        // Vytvoří aplikaci
        _init: function() {
            this.application = new Gtk.Application();
    
           // Napojí signály "activate" a "startup" k jejich obsluze.
           this.application.connect('activate', Lang.bind(this, this._onActivate));
           this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Vytvoří uživatelské rozhraní
        _buildUI: function() {
            this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                       title: "Hello World!" });
        },
    
        // Obsluha pro signál "activate"
        _onActivate: function() {
            // Zobrazí okno a všchny jeho synovské widgety
            this._window.show_all();
        },
    
        // Obsluha pro signál "startup"
        _onStartup: function() {
            this._buildUI();
        }
    });

note: (itstool) path: section/p
en: GtkApplication initializes GTK+. It also connects the <gui>x</gui> button that's automatically generated along with the window to the "destroy" signal.
cs: GtkApplication inicializuje GTK+. Rovněž napojí tlačítko <gui>×</gui>, které je u okna vygenerováno automaticky, k signálu <code>"destroy"</code>.

note: (itstool) path: section/p
en: We can start building our first window. We do this by creating a variable called <var>_window</var> and assigning it a new Gtk.ApplicationWindow.
cs: Můžeme začít sestavovat naše první okno. Provedeme to vytvořením proměnné s názvem <var>_window</var>, které přiřadíme <code>new Gtk.ApplicationWindow</code>.

note: (itstool) path: section/p
en: We give the window a property called <var>title</var>. The title can be any string you want it to be. To be on the safe side, it's best to stick to UTF-8 encoding.
cs: Nastavíme vlastnost okna nazvanou <var>title</var>. Může jí být libovolný řetězec, který bude sloužit jako jeho název v záhlaví. Je dobré lpět na kódování UTF-8.

note: (itstool) path: section/p
en: Now we have a window which has a title and a working "close" button. Let's add the actual "Hello World" text.
cs: Nyní máme okno, která má název a funkční „zavírací“ tlačítko. Pojďme přidat pořádný text „Hello World“.

note: (itstool) path: section/title
en: Label for the window
cs: Popisek pro okno

note: (itstool) path: section/code
en: // Add a label widget to your window
    this.label = new Gtk.Label({ label: "Hello World" });
    this._window.add(this.label);
    this._window.set_default_size(200, 200);
cs: // Přidání widgetu popisku do vašeho okna
    this.label = new Gtk.Label({ label: "Hello World" });
    this._window.add(this.label);
    this._window.set_default_size(200, 200);

note: (itstool) path: section/p
en: A text label is one of the GTK+ widgets we can use, on account of having imported the GTK+ library. To use it, we create a new variable called label, and assign it a new Gtk.Label. Then we give it properties inside the curly braces {}. In this case, we're setting the text that the label will hold. Finally, we create and run the application:
cs: Textový popisek je jeden z widgetů GTK+, který můžeme použít na základě toho, že jsme importovali knihovnu GTK+. Abychom jej mohli použít, vytvoříme proměnnou nazvanou <var>label</var> a přiřadíme ji <code>new Gtk.Label</code>. Pak ji mezi složenými závorkami {} udáme vlastnosti. V tomto případě nastavujeme text, který je v popisku obsažen. Nakonec vytvoříme a spustíme aplikaci:

note: (itstool) path: section/code
en: //run the application
    let app = new Application();
    app.application.run(ARGV);
cs: // Spustí aplikaci
    let app = new Application();
    app.application.run(ARGV);

note: (itstool) path: section/p
en: Gtk.ApplicationWindow can only hold one widget at a time. To construct more elaborate programs you need to create a holder widget like Gtk.Grid inside the window, and then add all the other widgets to it.
cs: Gtk.Application může v jednu chvíli obsahovat jen jeden widget. Pokud chcete sestrojit složitější program, budete uvnitř okna potřebovat vytvořit kontejnerový widget, jako je <code>Gtk.Grid</code>, a všechny ostatní widgety přidat do něj.

note: (itstool) path: section/p
en: The complete file:
cs: Celý soubor:

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    const Lang = imports.lang;
    
    imports.gi.versions.Gtk = '3.0'
    const Gtk = imports.gi.Gtk;
    
    class Application {
    
        //create the application
        constructor() {
            this.application = new Gtk.Application();
    
           //connect to 'activate' and 'startup' signals to handlers.
           this.application.connect('activate', this._onActivate.bind(this));
           this.application.connect('startup', this._onStartup.bind(this));
        }
    
        //create the UI
        _buildUI() {
            this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                       title: "Hello World!" });
            this._window.set_default_size(200, 200);
            this.label = new Gtk.Label({ label: "Hello World" });
            this._window.add(this.label);
        }
    
        //handler for 'activate' signal
        _onActivate() {
            //show the window and all child widgets
            this._window.show_all();
        }
    
        //handler for 'startup' signal
        _onStartup() {
            this._buildUI();
        }
    };
    
    //run the application
    let app = new Application();
    app.application.run(ARGV);
cs: #!/usr/bin/gjs
    
    const Lang = imports.lang;
    
    imports.gi.versions.Gtk = '3.0'
    const Gtk = imports.gi.Gtk;
    
    class Application {
    
        // Vytvoří aplikaci
        constructor() {
            this.application = new Gtk.Application();
    
           // Napojí signály "activate" a "startup" k jejich obsluze.
           this.application.connect('activate', this._onActivate.bind(this));
           this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Vytvoří uživatelské rozhraní
        _buildUI() {
            this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                       title: "Hello World!" });
            this._window.set_default_size(200, 200);
            this.label = new Gtk.Label({ label: "Hello World" });
            this._window.add(this.label);
        }
    
        // Obsluha pro signál "activate"
        _onActivate() {
            //show the window and all child widgets
            this._window.show_all();
        }
    
        // Obsluha pro signál "startup"
        _onStartup() {
            this._buildUI();
        }
    };
    
    // Spustí aplikaci
    let app = new Application();
    app.application.run(ARGV);

note: (itstool) path: section/title
en: Running the application from terminal
cs: Spuštění aplikace z terminálu

note: (itstool) path: section/p
en: To run this application, first save it as hello-world.js. Then open Terminal, go to the folder where your application is stored and run:
cs: Abyste mohli tuto aplikaci spustit, nejprve uložte hello-world.js. Pak otevřete terminál, přejděte do složky, kde je vaše aplikace uložená a spusťte:

note: (itstool) path: section/title
en: The <file>.desktop.in</file> file
cs: Soubor <file>.desktop.in</file>

note: (itstool) path: section/p
en: Running applications from the Terminal is useful at the beginning of the application making process. To have fully working <link href="https://developer.gnome.org/integration-guide/stable/mime.html.en">application integration</link> in GNOME 3 requires a desktop launcher. For this you need to create a <file>.desktop</file> file. The <file>.desktop</file> file describes the application name, the used icon and various integration bits. A deeper insight into the <file>.desktop</file> file can be found <link href="http://developer.gnome.org/desktop-entry-spec/">here</link>. The <file>.desktop.in</file> file will create the <file>.desktop</file>.
cs: Spouštění aplikace z terminálu je užitečné na začátku při postupném vytváření aplikace. Abychom dostali plně funkční <link href="https://developer.gnome.org/integration-guide/stable/mime.html.cs">aplikaci integrovanou</link> s GNOME 3, potřebujeme spouštěč do pracovního prostředí. K tomu musíte vytvořit soubor <file>.desktop</file>. Soubor <file>.desktop</file> popisuje název aplikace, použitou ikonu a různé integrační drobnosti. Hlubší rozebrání souboru <file>.desktop</file> můžete najít <link href="http://developer.gnome.org/desktop-entry-spec/">zde</link>. Ze souboru <file>.desktop.in</file> se vytvoří soubor <file>.desktop</file>.

note: (itstool) path: note/p
en: Before continuing, resave <file>hello-world.js</file> as <file>hello-world</file>. Then run this in the command line:
cs: Než budete pokračovat, přeuložte <file>hello-world.js</file> jako <file>hello-world</file>. Pak spusťte v příkazovém řádku:

note: (itstool) path: section/p
en: The example shows you the minimum requirements for a <code>.desktop.in</code> file.
cs: Příklad ukazuje minimální požadavky pro soubor <code>.desktop.in</code>.

note: (itstool) path: section/p
en: Save this as <file>hello-world.desktop.in</file>. Now let's go through some parts of the <code>.desktop.in</code> file.
cs: Uložte jej jako <file>hello-world.desktop.in</file>. Nyní se pojďme podívat na některé části souboru <code>.desktop.in</code>.

note: (itstool) path: item/p
en: The application name.
cs: Název aplikace.

note: (itstool) path: item/p
en: A short description of the application.
cs: Krátký popis aplikace.

note: (itstool) path: item/p
en: Specifies a command to execute when you choose the application from the menu. In this example exec just tells where to find the <file>hello-world</file> file and the file takes care of the rest.
cs: Určuje příkaz, který se má spustit, když aplikaci vyberete v nabídce. V tomto příkladu Exec jednoduše říká, kde najít soubor <file>hello-world</file> a tento soubor se už postará o zbytek.

note: (itstool) path: item/p
en: Specifies whether the command in the Exec key runs in a terminal window.
cs: Určuje, jestli příkaz v klíči Exec běží v terminálu.

note: (itstool) path: section/p
en: To put your application into the appropriate category, you need to add the necessary categories to the Categories line. More information on the different categories can be found in the <link href="http://standards.freedesktop.org/menu-spec/latest/apa.html">menu specification</link>.
cs: Abyste vaši aplikaci umístili do správné kategorie, musíte potřebné kategorie přidat na řádek <code>Categories</code>. Více informací o různých kategoriích můžete najít ve <link href="http://standards.freedesktop.org/menu-spec/latest/apa.html">specifikaci nabídky</link>.

note: (itstool) path: section/p
en: In this example we use an existing icon. For a custom icon you need to have a .svg file of your icon, stored in <file>/usr/share/icons/hicolor/scalable/apps</file>. Write the name of your icon file to the .desktop.in file, on line 7. More information on icons in: <link href="https://wiki.gnome.org/Initiatives/GnomeGoals/AppIcon">Installing Icons for Themes</link> and <link href="http://freedesktop.org/wiki/Specifications/icon-theme-spec">on freedesktop.org: Specifications/icon-theme-spec</link>.
cs: V tomto příkladu používáme existující ikonu. Pro vlastní ikonu potřebujete mít soubor SVG se svojí ikonou uložený v <file>/usr/share/icons/hicolor/scalable/apps</file>. Napište název svého souboru s ikonou do souboru .desktop.in na řádek 7. Více informací o ikonách: <link href="https://wiki.gnome.org/Initiatives/GnomeGoals/AppIcon">Instalace ikon pro motivy</link> a <link href="http://freedesktop.org/wiki/Specifications/icon-theme-spec">Specifikace/icon-theme-spec na freedesktop.org</link>.

note: (itstool) path: section/title
en: The build system
cs: Sestavovací systém

note: (itstool) path: section/p
en: To make your application truly a part of the GNOME 3 system you need to install it with the help of autotools. The autotools build will install all the necessary files to all the right places.
cs: Aby se vaše aplikace stala opravdu součástí systému GNOME 3, je potřeba ji nainstalovat za pomoci autotools. Autotools nainstaluje všechny nutné soubory na správná místa.

note: (itstool) path: section/p
en: For this you need to have the following files:
cs: K tomu budete potřebovat následující soubory:

note: (itstool) path: section/code
en: #!/bin/sh
    
    set -e
    
    test -n "$srcdir" || srcdir=`dirname "$0"`
    test -n "$srcdir" || srcdir=.
    
    olddir=`pwd`
    cd "$srcdir"
    
    # This will run autoconf, automake, etc. for us
    autoreconf --force --install
    
    cd "$olddir"
    
    if test -z "$NOCONFIGURE"; then
      "$srcdir"/configure "$@"
    fi
cs: #!/bin/sh
    
    set -e
    
    test -n "$srcdir" || srcdir=`dirname "$0"`
    test -n "$srcdir" || srcdir=.
    
    olddir=`pwd`
    cd "$srcdir"
    
    # Toto nám spustí autoconf, automake, atd.
    autoreconf --force --install
    
    cd "$olddir"
    
    if test -z "$NOCONFIGURE"; then
      "$srcdir"/configure "$@"
    fi

note: (itstool) path: section/p
en: After the <file>autogen.sh</file> file is ready and saved, run:
cs: Když máme soubor <file>autogen.sh</file> připravený a uložený, spusťte:

note: (itstool) path: section/code
en: # The actual runnable program is set to the SCRIPTS primitive.
    # # Prefix bin_ tells where to copy this
    bin_SCRIPTS = hello-world
    # # List of files to be distributed
    EXTRA_DIST =  \
    	$(bin_SCRIPTS)
    #
    #     # The desktop files
    desktopdir = $(datadir)/applications
    desktop_DATA = \
    	hello-world.desktop
cs: # Skutečný spustitelný program je nastaven do primitiva SCRIPTS
    # # Prefix bin_ říká, kam to nakopírovat
    bin_SCRIPTS = hello-world
    # # Seznam souborů, které se mají šířit
    EXTRA_DIST =  \
    	$(bin_SCRIPTS)
    #
    #     # Soubory .desktop
    desktopdir = $(datadir)/applications
    desktop_DATA = \
    	hello-world.desktop

note: (itstool) path: section/code
en: # This file is processed by autoconf to create a configure script
    AC_INIT([Hello World], 1.0)
    AM_INIT_AUTOMAKE([1.10 no-define foreign dist-xz no-dist-gzip])
    AC_CONFIG_FILES([Makefile hello-world.desktop])
    AC_OUTPUT
cs: # Tento soubor je zpracován pomocí autoconf, aby se vytvořil skript configure
    AC_INIT([Hello World], 1.0)
    AM_INIT_AUTOMAKE([1.10 no-define foreign dist-xz no-dist-gzip])
    AC_CONFIG_FILES([Makefile hello-world.desktop])
    AC_OUTPUT

note: (itstool) path: section/p
en: Information users should read first. This file can be blank.
cs: Informace, které by si měl uživatel pro začátek přečíst. Tento soubor může být prázdný.

note: (itstool) path: section/p
en: When you have the <file>hello-world</file>, <file>hello-world.desktop.in</file>, <file>Makefile.am</file>, <file>configure.ac</file> and <file>autogen.sh</file> files with correct information and permissions, create a <file>README</file> file with installation instructions. Below is a sample of what suitable README instructions may look like:
cs: Když máme soubory <file>hello-world</file>, <file>hello-world.desktop.in</file>, <file>Makefile.am</file>, <file>configure.ac</file> a <file>autogen.sh</file> se správnými informacemi a oprávněními, můžeme vytvořit soubor <file>README</file> s intrukcemi pro instalaci. Níže je příklad, jak může README s vhodným popisem vypadat:

note: (itstool) path: item/p
en: create a small "Hello, World" application using Python and GTK+
cs: vytvořit malou aplikaci „Hello, World“ pomocí jazyka Python a GTK+

note: (itstool) path: section/code
en: class MyWindow(Gtk.ApplicationWindow):
    
        # constructor for a Gtk.ApplicationWindow
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Hello World!", application=app)
            self.set_default_size(200, 100)
    
    class MyApplication(Gtk.Application):
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
cs: class MyWindow(Gtk.ApplicationWindow):
    
        # konstruktor pro Gtk.ApplicationWindow
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Hello World!", application=app)
            self.set_default_size(200, 100)
    
    class MyApplication(Gtk.Application):
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)

note: (itstool) path: section/p
en: Gtk.Application initializes GTK+. It also connects the <gui>x</gui> button that's automatically generated along with the window to the "destroy" signal.
cs: <code>Gt.Application</code> inicializuje GTK+. Rovněž napojí tlačítko <gui>×</gui>, které je vytvořeno automaticky spolu s oknem, na signál <code>"destroy"</code>.

note: (itstool) path: section/p
en: We can start building our first window. We do this by creating a class called <var>MyWindow</var> and assigning it a Gtk.ApplicationWindow.
cs: Můžeme začít sestavovat naše první okno. Provedeme to vytvořením proměnné s názvem <var>MyWindow</var>, které přiřadíme <code>new Gtk.ApplicationWindow</code>.

note: (itstool) path: section/code
en: # Add a label widget to your window
    
            # create a label
            label = Gtk.Label()
    
            # set the text of the label
            label.set_text("Hello GNOME!")
    
            # add the label to the window
            self.add(label)
cs: # Přidá widget Label do vašeho okna
    
            # Vytvoří popisek
            label = Gtk.Label()
    
            # Nastaví popisku text
            label.set_text("Hello GNOME!")
    
            # Přidá popisek do okna
            self.add(label)

note: (itstool) path: section/p
en: A text label is one of the GTK+ widgets we can use, on account of having imported the GTK+ library. To use it, we create a variable called <var>label</var> and set the text that the label will hold. Finally, we create and run the application:
cs: Textový popisek je jeden z widgetů GTK+, který můžeme použít na základě toho, že jsme importovali knihovnu GTK+. Abychom jej mohli použít, vytvoříme proměnnou nazvanou <var>label</var> a nastavíme text, který popisek obsahuje. Nakonec vytvoříme a spustíme aplikaci.

note: (itstool) path: section/code
en: #run the application
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: # Spustí aplikaci
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # constructor for a Gtk.ApplicationWindow
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(200, 100)
    
            # create a label
            label = Gtk.Label()
            # set the text of the label
            label.set_text("Hello GNOME!")
            # add the label to the window
            self.add(label)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # Konstruktor pro Gtk.ApplicationWindow
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(200, 100)
    
            # Vytvoří popisek
            label = Gtk.Label()
            # Nastaví text popisku
            label.set_text("Hello GNOME!")
            # Přidá popisek do okna
            self.add(label)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/p
en: To run this application, first save it as hello-world.py. Then open Terminal, go to the folder where your application is stored and run:
cs: Když chcete tuto aplikaci spustit, nejprve ji uložte jako <file>hello-world.py</file>. Pak otevřete terminál, přejděte do složky, kde je aplikace uložená, a spusťte:

note: (itstool) path: section/p
en: Now let's go through some parts of the <code>.desktop.in</code> file.
cs: Nyní se pojďme podívat na některé části souboru <code>.desktop.in</code>.

note: (itstool) path: section/code
en: # The actual runnable program is set to the SCRIPTS primitive.
    # # Prefix bin_ tells where to copy this
    bin_SCRIPTS = hello-world.py
    # # List of files to be distributed
    EXTRA_DIST=  \
    	$(bin_SCRIPTS)
    #
    #     # The desktop files
    desktopdir = $(datadir)/applications
    desktop_DATA = \
    	hello-world.desktop
cs: # Skutečný spustitelný program je nastaven do primitiva SCRIPTS
    # # Prefix bin_ říká, kam to nakopírovat
    bin_SCRIPTS = hello-world.py
    # # Seznam souborů, které se mají šířit
    EXTRA_DIST=  \
    	$(bin_SCRIPTS)
    #
    #     # Soubory .desktop
    desktopdir = $(datadir)/applications
    desktop_DATA = \
    	hello-world.desktop

note: (itstool) path: section/p
en: When you have the <file>hello-world</file>, <file>hello-world.desktop.in</file>, <file>Makefile.am</file>, <file>configure.ac</file> and <file>autogen.sh</file> files with correct information and rights, the <file>README</file> file can include the following instructions:
cs: Když máme soubory <file>hello-world</file>, <file>hello-world.desktop.in</file>, <file>Makefile.am</file>, <file>configure.ac</file> a <file>autogen.sh</file> se správnými informacemi a v pořádku, může soubor <file>README</file> obsahovat následující instrukce:

note: (itstool) path: item/p
en: create a small "Hello, World" application using GTK+
cs: vytvořit malou aplikaci „Hello, World“ pomocí GTK+

note: (itstool) path: section/p
en: We can start building our first window. We do this by creating a variable called <var>window</var> and assigning it a new Gtk.ApplicationWindow.
cs: Můžeme začít sestavovat naše první okno. Provedeme to vytvořením proměnné s názvem <var>window</var>, které přiřadíme <code>new Gtk.ApplicationWindow</code>.

note: (itstool) path: section/p
en: We give the window a title using <code>set_title</code>. The title can be any string you want it to be. To be on the safe side, it's best to stick to UTF-8 encoding.
cs: Oknu přidělíme název pomocí <code>set_title</code>. Název může být libovolný řetězec, jaký se vám hodí. Je však dobrou praxí, aby byl v kódování UTF-8.

note: (itstool) path: section/p
en: Finally, we create and run the application:
cs: Nakonec vytvoříme a spustíme aplikaci:

note: (itstool) path: section/p
en: To run this application, first save it as hello-world.vala. Then open Terminal, go to the folder where your application is stored.
cs: Když chcete tuto aplikaci spustit, nejprve ji uložte jako <file>hello-world.vala</file>. Pak otevřete terminál a přejděte do složky, kde je aplikace uložená.

note: (itstool) path: section/p
en: Compile the program:
cs: Zkompilujte program:

note: (itstool) path: section/p
en: Run the program:
cs: Spusťte program:

note: (itstool) path: section/code
en: # The actual runnable program is set to the SCRIPTS primitive.
    # # Prefix bin_ tells where to copy this
    bin_PROGRAMS = hello-world
    hello_world_CFLAGS = $(gtk_CFLAGS)
    hello_world_LDADD = $(gtk_LIBS)
    hello_world_VALAFLAGS = --pkg gtk+-3.0
    hello_world_SOURCES = hello-world.vala
    
    desktopdir = $(datadir)/applications
    desktop_DATA = \
    	hello-world.desktop
cs: # Skutečný spustitelný program je nastaven do primitiva SCRIPTS
    # # Prefix bin_ říká, kam to nakopírovat
    bin_PROGRAMS = hello-world
    hello_world_CFLAGS = $(gtk_CFLAGS)
    hello_world_LDADD = $(gtk_LIBS)
    hello_world_VALAFLAGS = --pkg gtk+-3.0
    hello_world_SOURCES = hello-world.vala
    
    desktopdir = $(datadir)/applications
    desktop_DATA = \
    	hello-world.desktop

note: (itstool) path: section/code
en: # This file is processed by autoconf to create a configure script
    AC_INIT([Hello World], 1.0)
    AM_INIT_AUTOMAKE([1.10 no-define foreign dist-xz no-dist-gzip])
    AC_PROG_CC
    AM_PROG_VALAC([0.16])
    PKG_CHECK_MODULES(gtk, gtk+-3.0)
    AC_CONFIG_FILES([Makefile hello-world.desktop])
    
    AC_OUTPUT
cs: # Tento soubor je zpracován pomocí autoconf, aby vytvořil skript configure
    AC_INIT([Hello World], 1.0)
    AM_INIT_AUTOMAKE([1.10 no-define foreign dist-xz no-dist-gzip])
    AC_PROG_CC
    AM_PROG_VALAC([0.16])
    PKG_CHECK_MODULES(gtk, gtk+-3.0)
    AC_CONFIG_FILES([Makefile hello-world.desktop])
    
    AC_OUTPUT

note: (itstool) path: section/p
en: When you have the <file>hello-world.c</file>, <file>hello-world.desktop.in</file>, <file>Makefile.am</file>, <file>configure.ac</file> and <file>autogen.sh</file> files with correct information and rights, the <file>README</file> file can include the following instructions:
cs: Když máme soubory <file>hello-world.c</file>, <file>hello-world.desktop.in</file>, <file>Makefile.am</file>, <file>configure.ac</file> a <file>autogen.sh</file> se správnými informacemi a v pořádku, může soubor <file>README</file> obsahovat následující instrukce:

note: (itstool) path: info/desc
en: A widget displaying an image
cs: Widget zobrazující obrázek

note: (itstool) path: page/p
en: This GtkApplication displays an image file from the current directory.
cs: Tato GtkApplication zobrazí soubor s obrázkem z aktuální složky.

note: (itstool) path: note/p
en: If the image file isn't loaded successfully, the image will contain a "broken image" icon. The <file>filename.png</file> needs to be in the current directory for this code to work. Use your favorite picture!
cs: V případě, že se soubor s obrázkem úspěšně nenačte, bude obrázek obsahovat ikonu „poškozený obrázek“. Aby tento program fungoval, musí se <file>gnome-image.png</file> nacházet v aktuální složce. Použijte svůj oblíbený obrázek!

note: (itstool) path: page/code
en: #include &lt;gtk/gtk.h&gt;
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *image;
    
      /*Create a window with a title and a default size*/
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Welcome to GNOME");
      gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
    
      image = gtk_image_new_from_file ("gnome-image.png");
    
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (image));
    
      gtk_widget_show_all (GTK_WIDGET (window));
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example",G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
      return status;
    }
cs: #include &lt;gtk/gtk.h&gt;
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *image;
    
      /* Vytvoří okno s názvem a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Welcome to GNOME");
      gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
    
      image = gtk_image_new_from_file ("gnome-image.png");
    
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (image));
    
      gtk_widget_show_all (GTK_WIDGET (window));
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example",G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
      return status;
    }

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class ImageExample {
    
        /* Create the application itself
           This boilerplate code is needed to build any GTK+ application. */
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jsimage',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal initializes menus and builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_height: 300,
                default_width: 300
            });
    
            // Create the label
            this.jsimage = new Gtk.Image ({file: "gnome-image.png"});
            this._window.add (this.jsimage);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    };
    
    // Run the application
    let app = new ImageExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class ImageExample {
    
        /* Vytvoří vlastní aplikaci
           This boilerplate code is needed to build any GTK+ application. */
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jsimage',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_height: 300,
                default_width: 300
            });
    
            // Vytvoří popisek
            this.label = new Gtk.Label ({label: "Hello GNOME!"});
            this._window.add (this.label);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    };
    
    // Spustí aplikaci
    let app = new ImageExample ();
    app.application.run (ARGV);

note: (itstool) path: note/p
en: If the image file is not loaded successfully, the image will contain a "broken image" icon. <file>filename.png</file> needs to be in the current directory for this code to work.
cs: V případě, že se soubor s obrázkem úspěšně nenačte, bude obrázek obsahovat ikonu „poškozený obrázek“. Aby tento program fungoval, musí se <file>název_souboru.png</file> nacházet v aktuální složce.

note: (itstool) path: section/code
en: 
      from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # create a window
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(300, 300)
    
            # create an image
            image = Gtk.Image()
            # set the content of the image as the file filename.png
            image.set_from_file("gnome-image.png")
            # add the image to the window
            self.add(image)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: 
      from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # Vytvoří okno
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(300, 300)
    
            # Vytvoří obrázek
            image = Gtk.Image()
            # Nastaví obsah obrázku na gnome-image.png
            image.set_from_file("gnome-image.png")
            # Přidá obrázek do okna
            self.add(image)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/p
en: Another way to obtain what we have in the example is to create the image as an instance of another class and add it to the instance of <code>MyWindow</code> in the <code>do_activate(self)</code> method:
cs: Jiným způsobem, jak získat to, co máme v tomto příkladu, je vytvořit obrázek jako instanci jiné třídy a jeho přidání do instance <code>MyWindow</code> v metodě <code>do_activate(self)</code>:

note: (itstool) path: section/code
en: 
        # a class to create a window
        class MyWindow(Gtk.ApplicationWindow):
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(300, 300)
    
        # a class to create an image
        class MyImage(Gtk.Image):
        def __init__(self):
            Gtk.Image.__init__(self)
            self.set_from_file("gnome-image.png")
    
        class MyApplication(Gtk.Application):
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            # create an instance of MyWindow
            win = MyWindow(self)
            # create an instance of MyImage and add it to the window
            win.add(MyImage())
            # show the window and everything on it
            win.show_all()
cs: 
        # Třída pro vytvoření okna
        class MyWindow(Gtk.ApplicationWindow):
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(300, 300)
    
        # Třída pro vytvoření obrázku
        class MyImage(Gtk.Image):
        def __init__(self):
            Gtk.Image.__init__(self)
            self.set_from_file("gnome-image.png")
    
        class MyApplication(Gtk.Application):
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            # Vytvoří instanci MyWindow
            win = MyWindow(self)
            # Vytvoří instanci MyImage a přidá ji do okna
            win.add(MyImage())
            # Zobrazí okno a vše v něm
            win.show_all()

note: (itstool) path: note/p
en: To use this code snippet, you will need to add the code that imports <code>Gtk</code> and <code>GdkPixbuf</code> from <code>gi.repository</code> and lines that instantiate the <code>MyApplication</code> window.
cs: Abyste mohli použít tento úryvek kódu, musíte přidat kód, který importuje <code>Gtk</code> a <code>GdkPixbuf</code> z <code>gi.repository</code> a řádky, které vytváří instanci okna <code>MyApplication</code>.

note: (itstool) path: section/title
en: Useful methods for an Image widget
cs: Užitečné metody pro widget Image

note: (itstool) path: item/p
en: To load an image over a network use <code>set_from_pixbuf(pixbuf)</code>, where <code>pixbuf</code> is a <link href="https://developer.gnome.org/gdk-pixbuf/unstable/index.html"> GdkPixbuf</link>.
cs: Pro načtení obrázku ze sítě použijte <code>set_from_pixbuf(pixbuf)</code>, kde <code>pixbuf</code> je <link href="https://developer.gnome.org/gdk-pixbuf/unstable/index.html">GdkPixbuf</link>.

note: (itstool) path: item/code
en: 
            from gi.repository import Gtk
            from gi.repository import GdkPixbuf
            import sys
    
            class MyWindow(Gtk.ApplicationWindow):
                # create a window
                def __init__(self, app):
                    Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
                    self.set_default_size(300, 300)
    
                    # create a pixbuf from file filename="gnome-image.png", with width=32
                    # and height=64 amd boolean preserve_aspect_ratio=False.
                    pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale("gnome-image.png", 64, 128, False)
    
                    # create an image
                    image = Gtk.Image()
                    # set the content of the image as the pixbuf
                    image.set_from_pixbuf(pixbuf)
                    # add the image to the window
                    self.add(image)
cs: 
            from gi.repository import Gtk
            from gi.repository import GdkPixbuf
            import sys
    
            class MyWindow(Gtk.ApplicationWindow):
                # Vytvoření okna
                def __init__(self, app):
                    Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
                    self.set_default_size(300, 300)
    
                    # Vytvoření pixbuf ze souboru filename="gnome-image.png" s šířkou width=32
                    # a výškou height=64 a s preserve_aspect_ratio=False.
                    pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale("gnome-image.png", 64, 128, False)
    
                    # Vytvoření obrázku
                    image = Gtk.Image()
                    # Nastavení obsahu obrázku z pixbuf
                    image.set_from_pixbuf(pixbuf)
                    # Přidání obrázku do okna
                    self.add(image)

note: (itstool) path: item/p
en: If <code>preserve_aspect_ratio=True</code> we can use <code>new_from_file_at_size(filename, width, height)</code>. If <code>width</code> or <code>height</code> is <code>-1</code>, it is not constrained.
cs: Pokud je <code>preserve_aspect_ratio=True</code> můžeme použít <code>new_from_file_at_size(název_souboru, šířka, výška)</code>. Když je <code>šířka</code> nebo <code>výška</code> rovna <code>-1</code>, znamená to bez omezení.

note: (itstool) path: item/p
en: For loading from an input stream, see <code>new_from_stream()</code> and <code>new_from_stream_at_scale()</code> in the documentation.
cs: Ohledně načtení ze vstupního datového proudu se podívejte do dokumentace na <code>new_from_stream()</code> a <code>new_from_stream_at_scale()</code>.

note: (itstool) path: item/p
en: <link href="https://developer.gnome.org/gtk3/unstable/GtkImage.html"> GtkImage</link>
cs: <link href="https://developer.gnome.org/gtk3/unstable/GtkImage.html">GtkImage</link>

note: (itstool) path: item/p
en: <link href="https://developer.gnome.org/gtk3/unstable/GtkWindow.html"> GtkWindow</link>
cs: <link href="https://developer.gnome.org/gtk3/unstable/GtkWindow.html">GtkWindow</link>

[ctx: text]
note: (itstool) path: info/title
en: Image viewer (C)
cs: Prohlížeč obrázků (C)

note: (itstool) path: info/desc
en: A little bit more than a simple "Hello world" Gtk application.
cs: O trošku složitější aplikace Gtk než jednoduché „Hello world“.

note: (itstool) path: page/title
en: Image viewer
cs: Prohlížeč obrázků

note: (itstool) path: synopsis/p
en: In this tutorial, you will learn:
cs: V této lekci se seznámíme s následujícími věcmi:

note: (itstool) path: item/p
en: Some basic concepts of C/GObject programming
cs: Některými základními koncepty programování v C s GObject

note: (itstool) path: item/p
en: How to write a Gtk application in C
cs: Jak psát aplikaci Gtk v C

note: (itstool) path: item/p
en: Choose <gui>GTK+ (Simple)</gui> from the <gui>C</gui> tab, click <gui>Continue</gui>, and fill out your details on the next few pages. Use <file>image-viewer</file> as project name and directory.
cs: Na kartě <gui>C</gui> zvolte <gui>GTK+ (jednoduchý)</gui>, klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>image-viewer</file>.

note: (itstool) path: item/p
en: Make sure that <gui>Use GtkBuilder for user interface</gui> is disabled as we will create the UI manually in this tutorial. Check the <link xref="guitar-tuner.c">Guitar-Tuner</link> tutorial if you want to learn how to use the interface builder.
cs: Ujistěte se, že <gui>Použít GtkBuilder k tvorbě uživatelského rozhraní</gui> je vypnuto, protože jej chceme v této lekci vytvořit ručně. Jestli se chcete naučit, jak používat návrhář uživatelského rozhraní, podívejte se do lekce <link xref="guitar-tuner.c">Kytarová ladička</link>.

note: (itstool) path: section/p
en: 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:
cs: C je celkem „upovídaný“ jazyk, takže nebuďte překvapeni, že soubor obsahuje poměrně hodně kódu. Většina toho je kód šablony. Načte (prázdné) okno a zobrazí jej. Dále to podrobněji rozebereme. Pokud jste již pochopili základy, tak tento seznam můžete přeskočit:

note: (itstool) path: item/p
en: The <code>create_window</code> function creates a new (empty) window and connects a signal to exit the application when that window is closed.
cs: Funkce <code>create_window</code> vytvoří nové (prázdné) okno a napojí signál, který zajistí ukončení aplikace, když je zavřeno okno.

note: (itstool) path: section/title
en: Creating the user interface
cs: Vytvoření uživatelského rozhraní

note: (itstool) path: section/p
en: 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>:
cs: Nyní prázdné okno oživíme. GTK uspořádává uživatelské rozhraní pomocí widgetů <code>GtkContainer</code>, které mohou obsahovat další widgety i další kontejnery. Zde použijeme nejjednodušší dostupný kontejner <code>GtkBox</code>:

note: (itstool) path: section/code
en: 
    static GtkWidget*
    create_window (void)
    {
    	GtkWidget *window;
    	GtkWidget *button;
    	GtkWidget *image;
    	GtkWidget *box;
    
    	/* Set up the UI */
    	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    	gtk_window_set_title (GTK_WINDOW (window), "image-viewer-c");
    
    	box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
    	button = gtk_button_new_with_label (_("Open image"));
    	image = gtk_image_new ();
    
    	gtk_box_pack_start (GTK_BOX (box), image, TRUE, TRUE, 0);
    	gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
    
    	gtk_container_add (GTK_CONTAINER (window), box);
    
    	/* Connect signals */
    
    	/* Show open dialog when opening a file */
    	g_signal_connect (button, "clicked", G_CALLBACK (on_open_image), image);
    
    	/* Exit when the window is closed */
    	g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
    
    	return window;
    }
cs: 
    static GtkWidget*
    create_window (void)
    {
    	GtkWidget *window;
    	GtkWidget *button;
    	GtkWidget *image;
    	GtkWidget *box;
    
    	/* Vytvoří uživatelské rozhraní */
    	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    	gtk_window_set_title (GTK_WINDOW (window), "image-viewer-c");
    
    	box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
    	button = gtk_button_new_with_label (_("Open image"));
    	image = gtk_image_new ();
    
    	gtk_box_pack_start (GTK_BOX (box), image, TRUE, TRUE, 0);
    	gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
    
    	gtk_container_add (GTK_CONTAINER (window), box);
    
    	/* Napojí signály */
    
    	/* Při otevírání souboru zobrazí dialogové okno pro výběr souboru */
    	g_signal_connect (button, "clicked", G_CALLBACK (on_open_image), image);
    
    	/* Skončit, když je zavřeno okno */
    	g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
    
    	return window;
    }

note: (itstool) path: item/p
en: 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.
cs: První řádek vytvoří widgety, které potřebujeme použít: tlačítko pro otevření obrázku, widget pro vlastní zobrazení obrázku a box, který použijeme jako kontejner. Makra, jako je <code>GTK_BOX</code> se používají pro dynamické typovou kontrolu a přetypování, což je potřeba, protože C nepodporuje samo o sobě objektově orientované programování.

note: (itstool) path: item/p
en: 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.
cs: Volání <code>gtk_box_pack_start</code> přidává dva widgety do boxu a definuje jejich chování. Obrázek se roztáhne přes veškeré dostupné místo, zatímco tlačítko bude jen tak velké, jak je potřeba. Všimněte si, že jsme u widgetů výslovně nenastavili velikost. GTK to obvykle nepotřebuje, což usnadňuje udělat rozvržení, které vypadá dobře při různých velikostech okna. Následně je box přidán do okna.

note: (itstool) path: item/p
en: 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.
cs: Potřebujeme nadefinovat, co se stane, když uživatel klikne na tlačítko. GTK používá koncept <em>signálů</em>. Když je kliknuto na tlačítko, spustí se signál <em>clicked</em>, který můžeme napojit na nějakou akci. To se udělá pomocí funkce <code>g_signal_connect</code>, která řekne GTK, aby zavolalo funkci <code>on_image_open</code>, když je na tlačítko kliknuto a předalo funkci obrázek jako dodatečný argument. Funkci <em>zpětného volání</em> nadefinujeme v další části.

note: (itstool) path: item/p
en: The last <code>g_signal_connect()</code> makes sure that the application exits when the window is closed.
cs: Poslední <code>g_signal_connect()</code> zajistí, že se aplikace ukončí při zavření okna.

note: (itstool) path: item/p
en: 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.
cs: Jako poslední krok zajistěte nahrazení volání <code>gtk_widget_show</code> ve funkci <code>main()</code> za <code>gtk_widget_show_all()</code>, aby se zobrazilo okno a všechny widgety v něm.

note: (itstool) path: section/title
en: Showing the image
cs: Zobrazení obrázku

note: (itstool) path: section/p
en: 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.
cs: Nyní nadefinujeme obsluhu signálu pro signál <em>clicked</em> tzn. pro tlačítko zmíněné dříve. Přidejte tento kód před metodu <code>create_window()</code>.

note: (itstool) path: section/p
en: This is a bit more complicated than anything we've attempted so far, so let's break it down:
cs: Toto je trochu komplikovanější než vše, o co jsme se doposud pokusili, takže si to pojďme rozebrat:

note: (itstool) path: item/p
en: 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.
cs: Prvním argumentem signálu je vždy widget, který signál vyslal. Někdy za ním může následovat další argument související se signálem, ale <em>clicked</em> žádný nemá. Další je argument <code>user_data</code>, což je ukazatel na data, která předáváme, když signál napojujeme. V tomto případě je to náš objekt <code>GtkImage</code>.

note: (itstool) path: item/p
en: 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.
cs: Následující řádek, který stojí za pozornost, je ten, kde je pomocí <code>gtk_file_chooser_dialog_new</code> vytvořeno dialogové okno pro výběr souboru. Funkce přebírá název dialogového okna, rodičovské okno a několik voleb, jako je počet tlačítek a jim příslušející hodnoty.

note: (itstool) path: item/p
en: 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.
cs: Všimněte si, že používáme <em>standardní</em> názvy tlačítek z Gtk, místo abychom ručně psali „Cancel“ nebo „Open“. Výhodou použití standardních názvů je, že popisky tlačítek budou vždy přeloženy do uživatelova jazyka.

note: (itstool) path: item/p
en: 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.
cs: Následující dva řádky omezí dialogové okno <gui>Open</gui>, aby zobrazovalo jen soubory, které lze otevřít pomocí <code>GtkImage</code>. Nejprve je vytvořen filtr a pak do něj přidáme všechny druhy souborů podporované v <code>GdkPixbuf</code> (což zahrnuje většinu obrázkových formátů, včetně PNG a JPEG). Nakonec tento filtr nastavíme aby byl filtrem dialogového okna <gui>Open</gui>.

note: (itstool) path: item/p
en: <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.
cs: <code>gtk_dialog_run</code> zobrazí dialogové okno <gui>Otevření</gui>. To bude čekat, až si uživatel vybere obrázek. Když to udělá, <code>gtk_dialog_run</code> vrátí hodnotu <code>GTK_RESPONSE_ACCEPT</code> (nebo by mohl vrátit <code>GTK_RESPONSE_CANCEL</code>, když uživatel klikne na <gui>Zrušit</gui>). V bloku <code>switch</code> se to otestuje.

note: (itstool) path: item/p
en: 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.
cs: Při předpokladu, že uživatel klikl na <gui>Open</gui>, následující řádek nastaví vlastnost <code>file</code> u <code>GtkImage</code> na název souboru s obrázkem, který uživatel vybral. <code>GtkImage</code> pak obrázek načte a zobrazí.

note: (itstool) path: item/p
en: 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.
cs: Na posledním řádku této metody zlikvidujeme dialogové okno <gui>Otevření</gui>, protože už jej nebudeme potřebovat. Tím se dialogové okno automaticky skryje.

note: (itstool) path: section/p
en: If you haven't already done so, choose the <file>Debug/src/image-viewer</file> application in the dialog that appears. Finally, hit <gui>Run</gui> and enjoy!
cs: Pokud jste tak ještě neučinili, zvolte aplikaci <file>Debug/src/image-viewer</file> v dialogovém okně, které se objeví. Nakonec klikněte na <gui>Spustit</gui> a užijte si ji!

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="image-viewer/image-viewer.c">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="image-viewer/image-viewer.c">ukázkovým kódem</link>.

note: (itstool) path: item/p
en: Have the user select a directory rather than a file, and provide controls to cycle through all of the images in a directory.
cs: Umožnit uživateli výběr složky místo souboru a poskytnout ovládání pro procházení všech obrázků v této složce.

note: (itstool) path: item/p
en: Apply random filters and effects to the image when it is loaded and allow the user to save the modified image.
cs: Použít při načtení obrázku náhodné filtry a efekty a umožnit uživateli takto změněný obrázek uložit.

note: (itstool) path: item/p
en: <link href="http://www.gegl.org/api.html">GEGL</link> provides powerful image manipulation capabilities.
cs: <link href="http://www.gegl.org/api.html">GEGL</link> poskytuje mocné schopnosti pro práci s obrázky.

note: (itstool) path: item/p
en: Allow the user to load images from network shares, scanners, and other more complicated sources.
cs: Umožnit uživateli načíst obrázky ze síťového sdílení, skenerů a dalších složitějších zdrojů.

note: (itstool) path: item/p
en: You can use <link href="http://library.gnome.org/devel/gio/unstable/">GIO</link> to handle network file transfers and the like, and <link href="http://library.gnome.org/devel/gnome-scan/unstable/">GNOME Scan</link> to handle scanning.
cs: Pro práci se síťovými přenosy můžete použít <link href="http://library.gnome.org/devel/gio/unstable/">GIO</link> a pro obsluhu skeneru <link href="http://library.gnome.org/devel/gnome-scan/unstable/">GNOME Scan</link>.

note: (itstool) path: info/desc
en: A little bit more than a simple "Hello world" GTKmm application.
cs: O trošku složitější aplikace GTKmm než jednoduché „Hello world“.

note: (itstool) path: item/p
en: Some basic concepts of C++/GObject programming
cs: Některé základní koncepty programování s C++/GObject

note: (itstool) path: item/p
en: How to write a Gtk application in C++
cs: Jak psát aplikace Gtk v jazyce C++

note: (itstool) path: item/p
en: Choose <gui>GTKmm (Simple)</gui> from the <gui>C++</gui> tab, click <gui>Forward</gui>, and fill out your details on the next few pages. Use <file>image-viewer</file> as project name and directory.
cs: Na kartě <gui>C++</gui> zvolte <gui>GTKmm (jednoduchý)</gui>. Klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>image-viewer</file>.

note: (itstool) path: item/p
en: Make sure that <gui>Use GtkBuilder for user interface</gui> is disabled as we will create the UI manually in this tutorial. Check the <link xref="guitar-tuner.cpp">Guitar-Tuner</link> tutorial if you want to learn how to use the interface builder.
cs: Ujistěte se, že <gui>Použít GtkBuilder k tvorbě uživatelského rozhraní</gui> je vypnuto, protože jej chceme v této lekci vytvořit ručně. Jestli se chcete naučit, jak používat návrhář uživatelského rozhraní, podívejte se do lekce <link xref="guitar-tuner.cpp">Kytarová ladička</link>.

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. Open <file>src/main.cc</file> from the <gui>Project</gui> or <gui>File</gui> tabs. You should see some code which starts with the lines:
cs: Klikněte na <gui>Použít</gui> a vytvoří se vám projekt. Otevřete <file>src/main.cc</file> na kartě <gui>Projekt</gui> nebo <gui>Soubor</gui>. Měli byste vidět kód, který začíná řádky:

note: (itstool) path: item/p
en: 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.
cs: Tři řádky <code>#include</code> na začátku vkládají knihovny <code>config</code> (užitečné definice pro sestavení pomocí autotools), <code>gtkmm</code> (uživatelské rozhraní) a <code>iostream</code> (C++-STL). Funkce z těchto knihoven se používají ve zbytku kódu.

note: (itstool) path: item/p
en: The <code>main</code> function creates a new (empty) window and sets the window title.
cs: Funkce <code>main</code> vytvoří nové (prázdné) okno a nastaví název do jeho záhlaví.

note: (itstool) path: item/p
en: 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.
cs: Funkce <code>kit::run()</code> spustí hlavní smyčku GTKmm, která spustí uživatelské rozhraní a začne naslouchat událostem (jako jsou kliknutí nebo zmáčknutí kláves). Protože jsme této funkci jako argument předali okno, ukončí se aplikace automaticky při zavření tohoto okna.

note: (itstool) path: section/p
en: 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>:
cs: Nyní oživíme prázdné okno. GTKmm uspořádává uživatelské rozhraní pomocí kontejneru <code>Gtk::Container</code>, který může obsahovat další widgety a také další kontejnery. Zde použijeme nejjednodušší dostupný kontejner <code>Gtk::Box</code>:

note: (itstool) path: item/p
en: 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.
cs: První řádky vytvoří widgety, které chceme používat: tlačítko pro otevření obrázku, vlastní widget pro zobrazení obrázku a box,, který použijeme jako kontejner.

note: (itstool) path: item/p
en: 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.
cs: Volání <code>pack_start</code> přidává dva widgety do boxu a definuje jejich chování. Obrázek se roztáhne přes veškeré dostupné místo, zatímco tlačítko bude jen tak velké, jak je potřeba. Všimněte si, že jsem u widgetů výslovně nenastavili velikost. GTKmm to obvykle nepotřebuje, což usnadňuje udělat rozvržení, které vypadá dobře při různých velikostech okna. Následně je box přidán do okna.

note: (itstool) path: item/p
en: We need to define what happens when the user clicks on the button. GTKmm uses the concept of <em>signals</em>. When the button is clicked, it fires the <em>clicked</em> signal, which we can connect to some action. This is done using the <code>signal_clicked().connect</code> method which tells GTKmm to call the <code>on_open_image</code> function when the button is clicked. We will define the <em>callback</em> in the next section.
cs: Potřebujeme nadefinovat, co se stane, když uživatel klikne na tlačítko. GTKmm používá koncept <em>signálů</em>. Když je kliknuto na tlačítko, spustí se signál <em>clicked</em>, který můžeme napojit na nějakou akci. To se udělá pomocí funkce <code>signal_clicked().connect</code>, která řekne GTKmm, aby zavolalo funkci <code>on_open_image</code>, když je na tlačítko kliknuto. Funkci <em>zpětného volání</em> nadefinujeme v další části.

note: (itstool) path: item/p
en: The last step is to show all widgets in the window using <code>show_all_children()</code>. This is equivalent to using the <code>show()</code> method on all our child widgets.
cs: Posledním krokem je zobrazit všechny widgety v okně pomocí <code>show_all_children()</code>. Je to stejné, jako byste zavolali metodu <code>show()</code> postupně u všech našich synovských widgetů.

note: (itstool) path: section/p
en: 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.
cs: Nyní budeme definovat obsluhu signálu pro signál <em>clicked</em> tzn. pro tlačítko zmíněné dříve. Přidejte tento kód před metodu <code>main</code>.

note: (itstool) path: item/p
en: The dialog for choosing the file is created using the <code>Gtk::FileChooserDialog</code> constructor. This takes the title and type of the dialog. In our case, it is an <em>Open</em> dialog.
cs: Dialogové okno pro výběr souboru je vytvořeno pomocí konstruktoru <code>Gtk::FileChooserDialog</code>. Jako argumenty přebírá název a typ dialogového okna. V našem případě je to dialogové okno <em>Open</em>.

note: (itstool) path: item/p
en: The next two lines add an <em>Open</em> and a <em>Close</em> button to the dialog.
cs: Následující dva řádky přidají do dialogového okna tlačítka <em>Open</em> a <em>Close</em>.

note: (itstool) path: item/p
en: 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.
cs: Druhým argumentem metody <code>add_button()</code> je hodnota identifikující kliknuté tlačítko. I zde použijeme předdefinované hodnoty poskytované GTKmm.

note: (itstool) path: item/p
en: 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.
cs: Následující dva řádky omezí dialogové okno <gui>Open</gui>, aby zobrazovalo jen soubory, které lze otevřít pomocí <code>Gtk::Image</code>. Nejprve je vytvořen filtr a pak do něj přidáme všechny druhy souborů podporované v <code>Gdk::Pixbuf</code> (což zahrnuje většinu obrázkových formátů, včetně PNG a JPEG). Nakonec tento filtr nastavíme aby byl filtrem dialogového okna <gui>Open</gui>.

note: (itstool) path: item/p
en: <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.
cs: <code>Glib::RefPtr</code> je chytrý ukazatel, který zde použijeme, aby se zajistilo, že filtr bude zlikvidován, až na něj nepovede žádný odkaz.

note: (itstool) path: item/p
en: <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.
cs: <code>dialog.run</code> zobrazí dialogové okno <gui>Open</gui>. Dialogové okno bude čekat na uživatele, než si vybere obrázek. Až tak učiní, vrátí <code>dialog.run</code> hodnotu <output>Gtk::RESPONSE_ACCEPT</output> nebo by mohl vrátit <output>Gtk::RESPONSE_CANCEL</output>, když uživatel klikne na <gui>Cancel</gui>. Otestujeme to výrazem <code>switch</code>.

note: (itstool) path: item/p
en: We hide the <gui>Open</gui> dialog because we don't need it any more. The dialog would be hidden later anyway, as it is only a local variable and is destroyed (and therefore hidden) when the scope ends.
cs: Skryjeme dialogové okno <gui>Open</gui>, protože jej již nebudeme potřebovat. Stejně by mohl být skryt později, protože jde jen o místní proměnnou a bude zlikvidována (a tím dialogové okno skryto), až se dorazí na konec rozsahu působnosti.

note: (itstool) path: item/p
en: 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.
cs: Při předpokladu, že uživatel klikl na <gui>Open</gui>, následující řádky načtou soubor do <code>Gtk::Image</code>, takže se zobrazí.

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="image-viewer/image-viewer.cc">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="image-viewer/image-viewer.cc">ukázkovým kódem</link>.

[ctx: text]
note: (itstool) path: info/title
en: Image viewer (JavaScript)
cs: Prohlížeč obrázků (JavaScript)

note: (itstool) path: info/desc
en: A little bit more than a simple "Hello world" application - write an image viewer in GTK+. Includes an introduction to the JavaScript language.
cs: O trošku složitější aplikace než jednoduché „Hello world“ – napíšeme prohlížeč obrázků v GTK+. Součástí je úvod do programovacího jazyka JavaScript.

note: (itstool) path: synopsis/p
en: In this tutorial, we're going to write a very simple GTK application that loads and displays an image file. You will learn how to:
cs: V této lekci napíšeme velmi jednoduchou aplikaci GTK, která načítá a zobrazuje soubory s obrázky. Naučíte se tyto věci:

note: (itstool) path: item/p
en: Write a basic GTK user interface in JavaScript
cs: Napsat základní uživatelské rozhraní GTK v jazyce JavaScript.

note: (itstool) path: item/p
en: Deal with events by connecting signals to signal handlers
cs: Zacházet s událostmi pomocí připojení signálu na obsluhu signálu.

note: (itstool) path: item/p
en: Lay out GTK user interfaces using containers
cs: Rozvrhnout uživatelské rozhraní GTK pomocí kontejnerů.

note: (itstool) path: item/p
en: Load and display image files
cs: Načíst a zobrazit soubor s obrázkem.

note: (itstool) path: item/p
en: An installed copy of the <em>gjs</em> interpreter
cs: Nainstalovanou kopii interpretu <em>gjs</em>

note: (itstool) path: item/p
en: Basic knowledge of any object-orientated programming language
cs: Základní znalosti objektově orientovaného programovacího jazyka

note: (itstool) path: item/p
en: Choose <gui>Generic Javascript</gui> from the <gui>JS</gui> tab, click <gui>Forward</gui>, and fill out your details on the next few pages. Use <file>image-viewer</file> as project name and directory.
cs: Na kartě <gui>JS</gui> zvolte <gui>Obecný JavaScript</gui>, klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>image-viewer</file>.

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. Open <file>src/main.js</file> from the <gui>Project</gui> or <gui>File</gui> tabs. It contains very basic example code.
cs: Klikněte na <gui>Použít</gui> a vytvoří se vám projekt. Otevřete <file>src/main.js</file> na kartě <gui>Projekt</gui> nebo <gui>Soubor</gui>. Bude obsahovat úplně základní příklad kódu.

note: (itstool) path: section/title
en: JavaScript basics: Hello World
cs: Základy v jazyce JavaScript: Hello World

note: (itstool) path: section/p
en: Before we start writing the image viewer, let's find out more about the way JavaScript is used in GNOME. Of course, your very first contact with any programming language should be the Hello World program which can already be found in <file>main.js</file>:
cs: Než začneme s psaním prohlížeče obrázků, pojďme se dozvědět něco víc o tom, jak se JavaScript používá v GNOME. Váš první kontakt s kterýmkoliv programovacím jazykem by samozřejmě měl být „Hello World“, který již najdete v <file>main.js</file>:

note: (itstool) path: section/p
en: This should look quite natural if you're familiar with almost any other programming language. The function <code>print</code> is called with the argument <code>"Hello world!"</code>, which will be printed on the screen. Note that each line of code ends with a semicolon.
cs: Jestli jste seznámení s kterýmkoliv programovacím jazykem, tohle by vám mělo připadat povědomé. Funkce <code>print</code> je volána s argumentem <code>"Hello world!"</code>, který bude vypsán na obrazovku. Všimněte si, že každý řádek je zakončen středníkem.

note: (itstool) path: section/title
en: Classes in JavaScript
cs: Třídy v jazyce JavaScript

note: (itstool) path: section/p
en: This is the standard way to define a class in JavaScript:
cs: Toto je standardní způsob, jak definovat třídu v jazyce JavaScript:

note: (itstool) path: section/p
en: This defines a class called <code>MyClass</code>. Let's go through each part of the class definition:
cs: Zde se definuje třída nazvaná <code>MyClass</code>. Pojďme si projít jednotlivé části definice třídy:

note: (itstool) path: item/p
en: <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.
cs: <code>function MyClass</code> je konstruktor třídy – jeho název musí odpovídat názvu třídy. Ke kterémukoliv členu třídy můžete přistupovat pomocí objektu <code>this</code>. Zde konstruktor volá metodu <code>_init</code> této třídy.

note: (itstool) path: item/p
en: 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.
cs: Blok <code>MyClass.prototype</code> je místo, kde se definuje <em>struktura</em> třídy. Každá třída se skládá z metod (funkce) a vlastností (proměnné). V tomto příkladu jsou tři metody a dvě vlastnosti.

note: (itstool) path: item/p
en: The first method defined here is called <code>_init</code>, and we specify that it is a function with no arguments:
cs: První zde definovaná metoda se nazývá <code>_init</code> a specifikujeme ji, jako funkci bez argumentů:

note: (itstool) path: item/p
en: 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.
cs: Napíšeme funkci dovnitř mezi složené závorky. Jsou zde definována dvě pole, <code>propertyA</code> a <code>propertyB</code>. První je nastavena na řetězec a druhá na celé číslo (10). Funkce nevrací žádnou hodnotu.

note: (itstool) path: item/p
en: 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>.
cs: Následující metoda se nazývá <code>aMethod</code> a má dva argumenty, které se při svém zavolání vypíše. Poslední metodou je <code>dumpProperties</code> a ta vypíše pole <code>propertyA</code> a <code>propertyB</code>.

note: (itstool) path: item/p
en: Note how the class definition (prototype) is arranged; each function definition is separated by a comma.
cs: Všimněte si, jak je definice třídy (prototyp) uspořádaná. Definice každé funkce je oddělena čárkou.

note: (itstool) path: section/p
en: Now that MyClass has been defined, we can play with it:
cs: Nyní je třída MyClass nadefinována a můžeme si s ní hrát:

note: (itstool) path: section/p
en: 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).
cs: Tento kód vytvoří novou instanci třídy nazývanou <var>o</var>, spustí <code>aMethod</code>, změní <code>propertyA</code> na jiný řetězec a pak zavolá <code>dumpProperties</code> (která vypíše vlastnosti).

note: (itstool) path: section/p
en: 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.
cs: Uložte kód do <file>main.js</file> a následně jej spusťte pomocí <guiseq><gui>Spustit</gui> <gui>Provést</gui></guiseq> v nabídce nebo pomocí nástrojové lišty.

note: (itstool) path: section/title
en: A first Gtk application
cs: První aplikace Gtk

note: (itstool) path: section/p
en: Let's see what a very basic Gtk application looks like in JavaScript:
cs: Podívejme se, jak vypadá úplně základní aplikace Gtk v jazyce JavaScript:

note: (itstool) path: section/p
en: Let's take a look at what's happening:
cs: Podívejme se, co se stane:

note: (itstool) path: item/p
en: 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.
cs: První řádek importuje jmenný prostor Gtk (tzn. vloží knihovnu Gtk). Knihovny jsou poskytovány pomocí GObject Introspection (gi), který poskytuje vazbu jazyka pro řadu knihoven GNOME.

note: (itstool) path: item/p
en: <code>Gtk.init</code> initializes the Gtk library; this statement is mandatory for all Gtk programs.
cs: <code>Gtk.init</code> inicializuje knihovnu Gtk. Tato část je povinná pro všechny programy Gtk.

note: (itstool) path: item/p
en: 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.
cs: Následující řádek vytvoří hlavní okno vytvořením nového objektu <code>Gtk.Window</code>. Konstruktoru okna můžete předat několik vlastností pomocí syntaxe <code>{vlastnost: hodnota, vlastnost: hodnota, …}</code>. V tomto případě nastavujeme název okna.

note: (itstool) path: item/p
en: The next line explicitly shows the window. In Gtk, every widget is hidden by default.
cs: Následující řádek zajistí zobrazení okna. V Gtk je každý widget ve výchozím stavu skrytý.

note: (itstool) path: item/p
en: 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.
cs: Nakonec <code>Gtk.main</code> spustí hlavní smyčku – jinými slovy provádění programu. Hlavní smyčka naslouchá událostem (signálům) od uživatelského rozhraní a následně volá obsluha signálu, které provede něco užitečného. Krátce si povíme něco o signálech.

note: (itstool) path: section/p
en: 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.
cs: Uložte kód do <file>main.js</file> a spusťte jej. Budete upozorněni, že aplikace se neukončí, když zavřete okno. To je tím, že zatím nemáme nastavenu obsluhu signálu <code>"destroy"</code> (close) od okna. Uděláme to za chvíli, prozatím ale použijte k ukončení programu zmáčknutí <keyseq><key>Ctrl</key> <key>C</key></keyseq> v terminálu.

note: (itstool) path: section/title
en: Adding classes
cs: Přidání tříd

note: (itstool) path: section/p
en: The proper way of doing Gtk programming is by using classes. Let's rewrite the simple code you just wrote using classes:
cs: Správný způsob, jak programovat s Gtk, je používat třídy. Pojďme přepsat jednoduchý kód, který jste již napsali, pomocí tříd:

note: (itstool) path: section/p
en: 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>).
cs: Všimněte si, že program je ten stejný. Jen jsme přesunuli kód vytvářející okno do samostatné třídy <code>ImageViewer</code>. Konstruktor třídy volá metodu <code>_init</code>, která vytvoří a zobrazí okno. Potom vytvoříme instanci třídy před spuštěním hlavní smyčky (<code>Gtk.main</code>).

note: (itstool) path: section/p
en: This code is modular and can be split into multiple files easily. This makes it cleaner and easier to read.
cs: Tento kód je modulární a můžeme jej snadno rozdělit do více souborů. Díky tomu bude čistější a snadnější ke čtení.

note: (itstool) path: section/title
en: Signals
cs: Signály

note: (itstool) path: section/p
en: 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:
cs: Signály jsou klíčovým konceptem programování v Gtk. Kdykoliv se něco stane u nějakého objektu, tak onen objekt vyšle signál. Například, když je kliknuto na tlačítko, vyšle signál <code>"clicked"</code>. Pokud chcete, aby váš program něco udělal, když tato událost nastane, musíte napojit funkci („obsluhu signálu“) na tento signál. Zde je příklad:

note: (itstool) path: section/p
en: 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.
cs: Poslední dva řádky vytvoří <code>Gtk.Button</code> nazvané <code>b</code> a napojí jeho signál <code>clicked</code> na funkci <code>button_clicked</code>, která byla definována dříve. Pokaždé, když je kliknuto na tlačítko, provede se kód ve funkci <code>button_clicked</code>. Ten akorát vypíše zprávu.

note: (itstool) path: section/p
en: The syntax for connecting any signal to a function is:
cs: Syntax pro připojení nějakého signálu k funkci je:

note: (itstool) path: section/code
en: 
    object.connect (&lt;signal_name&gt;, &lt;function_to_be_called&gt;);
cs: 
    object.connect (&lt;název_signálu&gt;, &lt;funkce_která_se_má_volat&gt;);

note: (itstool) path: section/p
en: You can find signal definitions for any object in the <link href="https://developer.gnome.org/gtk3/stable/gtkobjects.html">GTK class reference</link>.
cs: Definice signálů pro všechny možné objekty najdete v <link href="https://developer.gnome.org/gtk3/stable/gtkobjects.html">Příručce ke třídám GTK</link>.

note: (itstool) path: note/p
en: You can simplify the code by making use of an inline function definition:
cs: Můžeme kód zjednodušit použitím vložené definice funkce:

note: (itstool) path: section/title
en: Closing the window
cs: Zavření okna

note: (itstool) path: section/p
en: When you close a Gtk window it's not really closed, it's hidden. This allows you to keep the window around (which is useful if you want to ask the user if they really want to close the window, for example).
cs: Když zavřete okno Gtk, ve skutečnosti se nezavře, ale skryje. To umožňuje zachovat si okno bokem (což se například hodí, když se chcete uživatele zeptat, jestli chce okno opravdu zavřít).

note: (itstool) path: section/p
en: In our case, we really do just want to close the window. The simplest way of doing this is by connecting the <code>hide</code> signal of the GtkWindow object to a function that closes the application. Go back to the <file>image-viewer.js</file> file and add the following code to the <code>_init</code> method, on the line above <code>this.window.show</code>:
cs: V našem případě opravdu chceme okno zavřít. Nejjednodušší způsob, jak to udělat, je napojit signál <code>"hide"</code> objektu <code>GtkWindow</code> na funkci, která zavře aplikaci. Běžte zpět do souboru <file>image-viewer.js</file> a přidejte následující kód do metody <code>_init</code> na řádek na <code>this.window.show</code>:

note: (itstool) path: section/p
en: 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.
cs: Tímto se napojí signál <code>"hide"</code> okna na funkci <code>main_quit</code> z Gtk, která ukončí provádění hlavní smyčky Gtk. Jakmile je hlavní smyčka dokončena, dojde k návratu z funkce <code>Gtk.main</code>. Náš program by pokračovat během kódu napsaného za řádkem <code>Gtk.main ()</code>, ale zatím tam žádný kód nemáme, takže program skončí.

note: (itstool) path: section/title
en: Containers: Laying-out the user interface
cs: Kontejnery: Rozvržení uživatelského rozhraní

note: (itstool) path: section/p
en: 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.
cs: Widgety (ovládací prvky, jako jsou tlačítka a popisky) lze v okně uspořádat pomocí <em>kontejnerů</em>. Můžete dohromady kombinovat různé kontejnery, jako jsou boxy nebo mřížky.

note: (itstool) path: section/p
en: 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.
cs: <code>Gtk.Window</code> je samo o sobě kontejner, ale přímo do něj můžete vložit jen jeden widget. My bychom měli rádi dva widgety, obrázek a tlačítko, takže musíme do okna vložit „vysokokapacitní“ kontejner, pro tyto další widgety. Je dostupná řada <link href="http://library.gnome.org/devel/gtk/stable/GtkContainer.html">typů kontejnerů</link>, ale my zde použijeme <code>Gtk.Box</code>. Ten může obsahovat několik widgetů uspořádaných vodorovně nebo svisle. Složitější rozvržení můžete udělat vložením několika boxů do jiného boxu atd.

note: (itstool) path: note/p
en: 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.
cs: Existuje návrhář grafického uživatelského rozhraní nazývaný <app>Glade</app>, který je zaintegrován i do IDE <app>Anjuta</app>. S ním můžete navrhovat uživatelské rozhraní opravdu snadno. V tomto příkladu ale vše napíšeme ručně.

note: (itstool) path: section/p
en: 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:
cs: Pojďme přidat box a widgety do okna. Vložte následující kód do metody <code>_init</code>, hned nad řádek <code>this.window.show</code>:

note: (itstool) path: section/p
en: 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.
cs: První řádek vytvoří <code>Gtk.Box</code> nazvaný <var>main_box</var> a nastaví dvě jeho vlastnosti: <code>orientation</code> (otočení) je nastavena na svislou (takže widgety jsou uspořádány do sloupce) a <code>spacing</code> (rozestupy) mezi widgety jsou nastaveny na 0 pixelů. Následující řádek pak přidá nově vytvořený <code>Gtk.Box</code> do okna.

note: (itstool) path: section/p
en: 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).
cs: Zatím okno obsahuje jen prázdný <code>Gtk.Box</code> a pokud spustíte program nyní, neuvidíte oproti dřívějšku žádné změny (<code>Gtk.Box</code> je průhledný kontejner, takže jej tam nemůžete vidět).

note: (itstool) path: section/title
en: Packing: Adding widgets to the container
cs: Balení: Přidání widgetů do kontejneru

note: (itstool) path: section/p
en: 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:
cs: Abyste přidali nějaké widgety do <code>Gtk.Box</code>, vložte následující kód přímo pod řádek <code>this.window.add (main_box)</code>:

note: (itstool) path: section/p
en: 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.
cs: První řádek vytvoří nový <code>Gtk.Image</code> nazvaný <code>image</code>, který bude použit k zobrazení souboru s obrázkem. Následně je widget obrázku přidán (<em>zabalen</em>) do kontejneru <var>main_box</var> pomocí metody <link href="http://library.gnome.org/devel/gtk/stable/GtkBox.html#gtk-box-pack-start"><code>pack_start</code></link> widgetu <code>Gtk.Box</code>.

note: (itstool) path: section/p
en: <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>).
cs: <code>pack_start</code> přebírá 4 argumenty: widget, který je přidáván do boxu (<code>child</code>); zda by se měl box zvětšit, když je přidán nový widget (<code>expand</code>); zda by měl nový widget zabrat všechno vytvořené dodatečné místo, když je box větší (<code>fill</code>); jak moc místa, v pixelech, by mělo být mezi widgetem a jeho sousedem uvnitř boxu (<code>padding</code>).

note: (itstool) path: section/p
en: 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.
cs: Kontejnery Gtk (a widgety) se dynamicky roztahují, aby zaplnily dostupné místo, pokud jim to tedy dovolíte. Neumisťujte widgety zadáváním přesných souřadnic x,y v okně. Místo toho je umisťujte relativně vůči sobě. To umožní oknu, které se o ně stará, jednodušeji měnit velikost a widgety by tak měli dostat automaticky rozumnou velikost ve většině situací.

note: (itstool) path: section/p
en: 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.
cs: Všimněte si také, jak jsou widgety uspořádány do hierarchie. Jakmile jsou zabaleny v <code>Gtk.Box</code>, je <code>Gtk.Image</code> považován za potomka <em>Gtk.Box</em>. To umožňuje zacházet se všemi potomky widgetu jako se skupinou. Například byste mohli skrýt <code>Gtk.Box</code>, což by zároveň skrylo i všechny jeho potomky.

note: (itstool) path: section/p
en: Now insert these two lines, below the two you just added:
cs: Nyní vložte tyto dva řádky pod ty dva, které jsme již přidali:

note: (itstool) path: section/p
en: 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.
cs: Tyto řádky jsou podobné jako první dva, ale tentokrát vytváří <code>Gtk.Button</code> a přidávají ho do widgetu <var>main_box</var>. Všimněte si, že zde nastavujeme argument <code>expand</code> (ten druhý) na <code>false</code>, zatímco pro <code>Gtk.Image</code> byl nastaven na <code>true</code>. To způsobí, že obrázek zabere všechno dostupné místo a tlačítko jen tolik místa, kolik potřebuje. Když okno maximalizujete, zůstane velikost tlačítka stejná, ale obrázek se zvětší, aby zabral celý zbytek okna.

note: (itstool) path: section/p
en: Finally, we must change the <code>this.window.show ();</code> line to read:
cs: Nakonec musíme změnit řádek <code>this.window.show ();</code> takto:

note: (itstool) path: section/p
en: 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.)
cs: Tím se zobrazí potomci v okně Gtk a všichni jejich potomci a potomci těchto potomků atd. (Pamatujte, že widgety Gtk jsou ve výchozím stavu skryté.)

note: (itstool) path: section/title
en: Loading the image: Connecting to the button's <code>clicked</code> signal
cs: Načtení obrázku: Napojení signálu <code>clicked</code> od tlačítka

note: (itstool) path: section/p
en: 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.
cs: Když uživatel klikne na tlačítko <gui>Open</gui>, mělo by se objevit dialogové okno, ve kterém si uživatel může vybrat obrázek. Až jej má vybraný, měl by se obrázek načíst a zobrazit ve widgetu obrázku.

note: (itstool) path: section/p
en: 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:
cs: Prvním krokem je napojení signálu <code>"clicked"</code> od tlačítka na funkci obsluhující signál, kterou nazveme <code>_openClicked</code>. Vložte tento kód hned za řádek <code>var open_button = new Gtk.Button</code>, kde je tlačítko vytvořeno:

note: (itstool) path: section/p
en: 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:
cs: Používáme zde pomocnou třídu jazyka JavaScript <code>Lang</code>. Ta umožňuje napojit na signál <em>metodu třídy</em> namísto prosté funkce (bez třídy), což jsem udělali před tím pro signál <code>"hide"</code> u okna. Teď si s tím nedělejte starosti, je to jen drobný technický detail. Aby to fungovalo, potřebujete navíc na začátek souboru vložit následující řádek:

note: (itstool) path: section/title
en: Loading the image: Writing the signal's callback
cs: Načítání obrázku: Psaní zpětných volání pro signály

note: (itstool) path: section/p
en: 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):
cs: Nyní můžeme vytvořit metodu <code>_openClicked()</code>. Vložte následující do bloku <code>ImageViewer.prototype</code> za metodu <code>_init</code> (a nezapomeňte na čárku):

note: (itstool) path: item/p
en: 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.
cs: Řádek začínající <code>var chooser</code> vytvoří dialogové okno <gui>Open</gui>, které může uživatel použít k výběru souboru. Nastavíme čtyři vlastnosti: název dialogového okna; akci (typ) dialogového okna (jde o dialogové okno <gui>Open</gui>, ale mohli bychom použít <code>SAVE</code>, pokud by záměrem bylo uložení souboru; <code>transient_for</code>, která nastaví rodičovské okno dialogového okna; <code>modal</code>, která, když je nastavena na <code>true</code>, zabrání uživateli kliknout na jiné místo aplikace, dokud není dialogové okno zavřeno.

note: (itstool) path: item/p
en: 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>.
cs: Následující dva řádky přidají do dialogového okna tlačítka <gui>Cancel</gui> a <gui>Open</gui>. Druhým argumentem metody <code>add_button</code> je celočíselná hodnota, která bude vrácena při zmáčknutí tlačítka: 0 pro <gui>Cancel</gui> a 1 pro <gui>Open</gui>.

note: (itstool) path: item/p
en: <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).
cs: <code>set_default_response</code> určuje tlačítko, které bude aktivováno, když uživatel dvojitě klikne na soubor nebo zmáčkne <key>Enter</key>. V našem případě používáme jako výchozí tlačítko <gui>Open</gui> (které má hodnotu 1).

note: (itstool) path: item/p
en: 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.
cs: Následující tři řádky omezí dialogové okno <gui>Open</gui>, aby zobrazovalo jen soubory, které lze otevřít pomocí <code>Gtk.Image</code>. Nejprve je vytvořen filtr a pak do něj přidáme všechny druhy souborů podporované v <code>Gdk.Pixbuf</code> (což zahrnuje většinu obrázkových formátů, včetně PNG a JPEG). Nakonec tento filtr nastavíme aby byl filtrem dialogového okna <gui>Open</gui>.

note: (itstool) path: item/p
en: <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.
cs: <code>chooser.run</code> zobrazí dialogové okno <gui>Open</gui>. Dialogové okno bude čekat na uživatele, než si vybere obrázek. Až tak učiní, vrátí <code>choose.run</code> hodnotu <output>1</output> nebo by mohl vrátit <output>0</output>, když uživatel klikne na <gui>Cancel</gui>. Otestujeme to výrazem <code>if</code>.

note: (itstool) path: item/p
en: 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.
cs: Předpokládejme, že uživatel klikl na <gui>Open</gui>. Následující řádek nastaví vlastnost <code>file</code> v <code>Gtk.Image</code> na název souboru s obrázkem, který si uživatel vybral. <code>Gtk.Image</code> vybraný obrázek načte a zobrazí.

note: (itstool) path: item/p
en: In the final line of this method, we destroy the <gui>Open</gui> dialog because we don't need it any more.
cs: Na posledním řádku této metody zlikvidujeme dialogové okno <gui>Open</gui>, protože jej již nebudeme potřebovat.

note: (itstool) path: section/p
en: 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!
cs: Všechen kód, který potřebujete, je nyní nachystaný, takže jej můžete zkusit spustit. Tím jste během krátké chvíle získali, co jsme slíbili – plně funkční prohlížeč obrázků (a tím končí naše cesta jazykem JavaScript a knihovnou Gtk).

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="image-viewer/image-viewer.js">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="image-viewer/image-viewer.js">ukázkovým kódem</link>.

[ctx: text]
note: (itstool) path: info/title
en: Image viewer (Python)
cs: Prohlížeč obrázků (Python)

note: (itstool) path: info/desc
en: A little bit more than a simple "Hello world" application - write an image viewer in GTK.
cs: O trošku složitější aplikace než jednoduché „Hello world“ – napíšeme prohlížeč obrázku v GTK.

note: (itstool) path: item/p
en: Write a basic GTK user interface in Python
cs: Psát základní uživatelské rozhraní GTK v jazyce Python

note: (itstool) path: item/p
en: Basic knowledge of the python programming language
cs: Základní znalosti programovacího jazyka Python

note: (itstool) path: item/p
en: Choose <gui>PyGTK (automake)</gui> from the <gui>Python</gui> tab, click <gui>Continue</gui>, and fill out your details on the next few pages. Use <file>image-viewer</file> as project name and directory.
cs: Na kartě <gui>Python</gui> zvolte <gui>PyGTK (automake)</gui>, klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>image-viewer</file>.

note: (itstool) path: item/p
en: 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>.
cs: Ujistěte se, že <gui>Použít GtkBuilder k tvorbě uživatelského rozhraní</gui> je vypnuto, protože jej chceme v této lekci vytvořit ručně. Na příklad, jak používat návrhář uživatelského rozhraní, se podívejte do lekce <link xref="guitar-tuner.py">Kytarová ladička</link>.

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. Open <file>src/image_viewer.py</file> from the <gui>Project</gui> or <gui>File</gui> tabs. It contains very basic example code.
cs: Klikněte na <gui>Použít</gui> a vytvoří se vám projekt. Otevřete <file>src/image_viewer.py</file> na kartě <gui>Projekt</gui> nebo <gui>Soubor</gui>. Obsahuje úplně základní kód příkladu.

note: (itstool) path: section/p
en: Let's see what a very basic Gtk application looks like in Python:
cs: Pojďme se podívat, jak by úplně základní aplikace Gtk mohl vypadat v jazyce Python:

note: (itstool) path: item/p
en: 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.
cs: Metoda <code>__init__</code> třídy <code>GUI</code> vytvoří (prázdné) okno <code>Gtk.Window</code>, nastaví jeho název do záhlaví a napojí signál, aby se aplikace ukončila při zavření okna. Toto je celkem jednoduché a více si o signálech povíme později.

note: (itstool) path: item/p
en: Next, <code>destroy</code> is defined which just quits the application. It is called by the <code>destroy</code> signal connected above.
cs: Pak je definována funkce <code>destroy</code>, která akorát ukončí aplikaci. Je volána signálem <code>"destroy"</code> napojeným již dříve.

note: (itstool) path: item/p
en: The rest of the file does initialisation for Gtk and displays the GUI.
cs: Zbytek souboru provádí inicializaci pro Gtk a zobrazí GUI.

note: (itstool) path: section/p
en: 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.
cs: Tento kód je připravený ke spuštění, takže zkuste použít <guiseq><gui>Spustit</gui> <gui>Spustit</gui></guiseq>. Mělo by se vám zobrazit prázdné okno.

note: (itstool) path: section/p
en: 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:
cs: Pojďme přidat box a widgety do okna. Vložte následující kód do metody <code>__init__</code>, hned za řádek <code>window.connect_after</code>:

note: (itstool) path: section/p
en: 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.
cs: První řádek vytvoří <code>Gtk.Box</code> nazvaný <code>box</code> a následující řádky nastaví dvě jeho vlastnosti: <code>orientation</code> (otočení) je nastavena na svislou (takže widgety jsou uspořádány do sloupce) a <code>spacing</code> (rozestupy) mezi widgety jsou nastaveny na 5 pixelů. Následující řádek pak přidá nově vytvořený <code>Gtk.Box</code> do okna.

note: (itstool) path: section/p
en: To add some widgets to the <code>Gtk.Box</code>, insert the following code directly below the <code>window.add (box)</code> line:
cs: Pro přidání nějakého widgetu do <code>Gtk.Box</code> vložte následující kód hned za řádek <code>window.add (box)</code>:

note: (itstool) path: section/p
en: 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.
cs: První řádek vytvoří nový <code>Gtk.Image</code> nazvaný <code>image</code>, který bude zobrazovat soubor s obrázkem. Protože jej budeme později potřebovat v obsluze signálu, nadefinujeme jej jako proměnou třídy. Musíte přidat <code>image = 0</code> na začátek třídy <code>GUI</code>. Po té je widget obrázku přidán (<em>zabalen</em>) do kontejneru <code>box</code> pomocí metody <link href="http://library.gnome.org/devel/gtk/stable/GtkBox.html#gtk-box-pack-start"><code>pack_start</code></link> widgetu <code>GtkBox</code>.

note: (itstool) path: section/p
en: <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>).
cs: <code>pack_start</code> přebírá 4 argumenty: widget, který je přidáván do <code>Gtk.Box</code> (<code>child</code>); zda by se měl <code>Gtk.Box</code> zvětšit, když je přidán nový widget (<code>expand</code>); zda by měl nový widget zabrat všechno vytvořené dodatečné místo, když je <code>Gtk.Box</code> větší (<code>fill</code>); jak moc místa, v pixelech, by mělo být mezi widgetem a jeho sousedem uvnitř <code>Gtk.Box</code> (<code>padding</code>).

note: (itstool) path: section/p
en: 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.
cs: Tyto řádky jsou podobné jako první dva, ale tentokrát vytváří <code>Gtk.Button</code> a přidávají ho do widgetu <code>box</code>. Všimněte si, že zde nastavujeme argument <code>expand</code> (ten druhý) na <code>False</code>, zatímco pro <code>Gtk.Image</code> byl nastaven na <code>True</code>. To způsobí, že obrázek zabere všechno dostupné místo a tlačítko jen tolik místa, kolik potřebuje. Když okno maximalizujete, zůstane velikost tlačítka stejná, ale obrázek se zvětší, aby zabral celý zbytek okna.

note: (itstool) path: section/p
en: 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.
cs: Když uživatel klikne na tlačítko <gui>Open Image…</gui>, mělo by se objevit dialogové okno, ve kterém si uživatel může vybrat obrázek. Až jej má vybraný, měl by se obrázek načíst a zobrazit ve widgetu obrázku.

note: (itstool) path: section/p
en: 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:
cs: Prvním krokem je napojit signál <code>clicked</code> od tlačítka na obslužnou funkci signálu, kterou jsem nazvali <code>on_open_clicked</code>. Vložte tento kód hned za řádek <code>button = Gtk.Button()</code>, kde bylo tlačítko vytvořeno:

note: (itstool) path: section/p
en: This will connect the <code>clicked</code> signal to <code>on_open_clicked</code> method that we will define below.
cs: Tímto se připojí signál <code>clicked</code> k metodě <code>on_open_clicked</code>, která bude definována níže.

note: (itstool) path: section/p
en: 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:
cs: Nyní vytvoříme metodu <code>on_open_clicked</code>. Vložte následující do bloku s kódem třídy <code>GUI</code> za metodu <code>__init__</code>:

note: (itstool) path: item/p
en: 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.
cs: Řádek začínající <code>dialog</code> vytvoří dialogové okno <gui>Open</gui>, které může uživatel použít k výběru souboru. Nastavíme tři vlastnosti: název dialogového okna; akci (typ) dialogového okna (jde o dialogové okno <gui>Open</gui>, ale mohli bychom použít <code>SAVE</code>, pokud by záměrem bylo uložení souboru; <code>transient_for</code>, která nastaví rodičovské okno dialogového okna.

note: (itstool) path: item/p
en: <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.
cs: <code>dialog.run</code> zobrazí dialogové okno <gui>Open</gui>. Dialogové okno bude čekat na uživatele, než si vybere nějaký nějaký obrázek. Až tak učiní, vrátí <code>dialog.run</code> hodnotu <output>1</output> nebo by mohl vrátit <output>0</output>, když uživatel klikne na <gui>Cancel</gui>. Otestujeme to výrazem <code>if</code>.

note: (itstool) path: section/p
en: 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!
cs: Všechen kód, který potřebujete, je nyní nachystaný, takže jej můžete zkusit spustit. Tím jste během krátké chvíle získali, co jsme slíbili – plně funkční prohlížeč obrázků (a tím končí naše cesta jazykem Python a knihovnou Gtk).

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="image-viewer/image-viewer.py">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="image-viewer/image-viewer.py">ukázkovým kódem</link>.

[ctx: text]
note: (itstool) path: info/title
en: Image viewer (Vala)
cs: Prohlížeč obrázků (Vala)

note: (itstool) path: info/desc
en: A little bit more than a simple "Hello world" GTK+ application.
cs: O trošku složitější aplikace GTK+ než jednoduché „Hello world“.

note: (itstool) path: synopsis/p
en: In this tutorial you will create an application which opens and displays an image file. You will learn:
cs: V této lekci vytvoříte aplikaci, která otevře a zobrazí soubor s obrázkem. Naučíte se:

note: (itstool) path: item/p
en: How to set up a basic project using the <link xref="getting-ready">Anjuta IDE</link>.
cs: Jak vytvořit základní projekt pomocí <link xref="getting-ready">IDE Anjuta</link>.

note: (itstool) path: item/p
en: How to write a <link href="http://developer.gnome.org/platform-overview/stable/gtk">Gtk application</link> in Vala
cs: Jak napsat <link href="http://developer.gnome.org/platform-overview/stable/gtk">aplikaci Gtk</link> v jazyce Vala.

note: (itstool) path: item/p
en: Some basic concepts of <link href="http://developer.gnome.org/gobject/stable/">GObject</link> programming
cs: Některé základní koncepty programování s <link href="http://developer.gnome.org/gobject/stable/">GObject</link>

note: (itstool) path: item/p
en: You may find the <link href="http://valadoc.org/gtk+-3.0/">gtk+-3.0</link> API Reference useful, although it is not necessary to follow the tutorial.
cs: Může se vám hodit referenční příručka k API <link href="http://valadoc.org/gtk+-3.0/">gtk+-3.0</link>, ačkoliv pro tuto výuku není nutná.

note: (itstool) path: item/p
en: From the <gui>Vala</gui> tab choose <gui>GTK+ (Simple)</gui>, click <gui>Continue</gui>, and fill out your details on the next page. Use <file>image-viewer</file> as project name and directory.
cs: Na kartě <gui>Vala</gui> zvolte <gui>GTK+ (jednoduchý)</gui>. Klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>image-viewer</file>.

note: (itstool) path: item/p
en: Make sure that <gui>Use GtkBuilder for user interface</gui> is unchecked as we will create the UI manually in this tutorial.
cs: Ujistěte se, že <gui>Použít GtkBuilder k tvorbě uživatelského rozhraní</gui> je vypnuto, protože jej chceme v této lekci vytvořit ručně.

note: (itstool) path: note/p
en: You will learn how to use the interface builder in the <link xref="guitar-tuner.vala">Guitar-Tuner</link> tutorial.
cs: Jak používat builder k tvorbě rozhraní se můžete naučit v lekci <link xref="guitar-tuner.vala">Kytarová ladička</link>.

note: (itstool) path: item/p
en: Click <gui>Continue</gui> then <gui>Apply</gui> and the project will be created for you. Open <file>src/image_viewer.vala</file> from the <gui>Project</gui> or <gui>File</gui> tabs. You will see this code:
cs: Klikněte na <gui>Pokračovat</gui> a pak na <gui>Použít</gui> a vytvoří se vám projekt. Otevřete <file>src/image_viewer.vala</file> na kartě <gui>Projekt</gui> nebo <gui>Soubor</gui>. Měli byste vidět kód, který začíná řádky:

note: (itstool) path: section/p
en: 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:
cs: Kód načte (prázdné) okno ze souboru s popisem uživatelského rozhraní a zobrazí jej. Dále to podrobněji rozebereme. Pokud jste již pochopili základy, tak tento seznam můžete přeskočit:

note: (itstool) path: item/p
en: The two <code>using</code> lines at the top import namespaces so we don't have to name them explicitly.
cs: Dva řádky <code>using</code> v horní části naimportují jmenné prostory, abychom je nemuseli výslovně uvádět.

note: (itstool) path: item/p
en: The constructor of the <code>Main</code> class creates a new (empty) window and connects a <link href="https://live.gnome.org/Vala/SignalsAndCallbacks">signal</link> to exit the application when that window is closed.
cs: Konstruktor třídy <code>Main</code> vytvoří nové (prázdné) okno a napojí <link href="https://live.gnome.org/Vala/SignalsAndCallbacks">signál</link>, aby se aplikace ukončila, když se zavře okno.

note: (itstool) path: item/p
en: The <code>static main</code> function is run by default when you start a Vala application. It calls a few functions which create the <code>Main</code> class, set up and then run the application. The <link href="http://valadoc.org/gtk+-3.0/Gtk.main.html"><code>Gtk.main</code></link> function starts the GTK <link href="http://en.wikipedia.org/wiki/Event_loop">main loop</link>, which runs the user interface and starts listening for events (like clicks and key presses).
cs: Funkce <code>static main</code> se spustí jako výchozí, když spustíte aplikaci napsanou v jazyce Vala. Volá pár funkcí, které vytvoří třídu <code>Main</code> a nastaví a spustí aplikaci. Funkce <link href="http://valadoc.org/gtk+-3.0/Gtk.main.html"><code>Gtk.main</code></link> spustí <link href="http://en.wikipedia.org/wiki/Event_loop">hlavní smyčku</link> GTK, která spustí uživatelské rozhraní a začne naslouchat událostem (jako je kliknutí nebo zmáčknutí klávesy).

note: (itstool) path: section/p
en: 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.
cs: Změňte <gui>Konfiguraci</gui> na <gui>Výchozí</gui> a klikněte na <gui>Spustit</gui>, aby se nakonfigurovala složka, ve které se provádí sestavení. Stačí to udělat jen jednou, pro první sestavení.

note: (itstool) path: section/p
en: Now we will bring life into the empty window. GTK organizes the user interface with <link href="http://www.valadoc.org/gtk+-2.0/Gtk.Container.html"><code>Gtk.Container</code></link>s that can contain other widgets and even other containers. Here we will use the simplest available container, a <link href="http://unstable.valadoc.org/gtk+-2.0/Gtk.Box.html"><code>Gtk.Box</code></link>.
cs: Nyní prázdné okno oživíme. GTK uspořádává uživatelské rozhraní pomocí widgetů <link href="http://www.valadoc.org/gtk+-2.0/Gtk.Container.html"><code>Gtk.Container</code></link>, které mohou obsahovat další widgety i další kontejnery. Zde použijeme nejjednodušší dostupný kontejner <link href="http://unstable.valadoc.org/gtk+-2.0/Gtk.Box.html"><code>Gtk.Box</code></link>.

note: (itstool) path: section/p
en: Add the following lines to the top of the <code>Main</code> class:
cs: Přidejte následující řádky na začátek třídy <code>Main</code>:

note: (itstool) path: section/p
en: Now replace the current constructor with the one below:
cs: Nyní nahraďte současný konstruktor tímto uvedeným níže:

note: (itstool) path: section/code
en: 
    
    public Main () {
    
    	window = new Window ();
    	window.set_title ("Image Viewer in Vala");
    
    	// Set up the UI
    	var box = new Box (Orientation.VERTICAL, 5);
    	var button = new Button.with_label ("Open image");
    	image = new Image ();
    
    	box.pack_start (image, true, true, 0);
    	box.pack_start (button, false, false, 0);
    	window.add (box);
    
    	// Show open dialog when opening a file
    	button.clicked.connect (on_open_image);
    
    	window.show_all ();
    	window.destroy.connect (main_quit);
    }
cs: 
    
    public Main () {
    
    	window = new Window ();
    	window.set_title ("Image Viewer in Vala");
    
    	// Nastaví uživatelské rozhraní
    	var box = new Box (Orientation.VERTICAL, 5);
    	var button = new Button.with_label ("Open image");
    	image = new Image ();
    
    	box.pack_start (image, true, true, 0);
    	box.pack_start (button, false, false, 0);
    	window.add (box);
    
    	// Zobrazí dialogové okno při otevírání souboru
    	button.clicked.connect (on_open_image);
    
    	window.show_all ();
    	window.destroy.connect (main_quit);
    }

note: (itstool) path: item/p
en: The first two lines are the parts of the GUI that we will need to access from more than one method. We declare them up here so that they are accessible throughout the class instead of only in the method where they are created.
cs: První dva řádky jsou částí GUI a budeme k nim potřebovat přístup z více než jedné metody. Proto je deklarujeme zde, takže budou přístupné skrze třídu. Jinak by byly přístupné jen v metodě, kde by byly vytvořeny.

note: (itstool) path: item/p
en: The first lines of the constructor create the empty window. The next lines create the widgets we want to use: a button for opening up an image, the image view widget itself and the box we will use as a container.
cs: První řádek konstruktoru vytvoří prázdné okno. Následující řádky vytvoří widgety, které chceme používat: tlačítko pro otevření obrázku, vlastní widget pro zobrazení obrázku a box sloužící jako kontejner.

note: (itstool) path: item/p
en: The calls to <link href="http://unstable.valadoc.org/gtk+-2.0/Gtk.Box.pack_start.html"><code>pack_start</code></link> add the two widgets to the box and define their behaviour. The image will expand into any available space whereas the button will just be as big as needed. You will notice that we don't set explicit sizes on the widgets. In GTK this is usually not needed as it makes it much easier to have a layout that looks good in different window sizes. Next, the box is added to the window.
cs: Volání <link href="http://unstable.valadoc.org/gtk+-2.0/Gtk.Box.pack_start.html"><code>pack_start</code></link> přidává dva widgety do boxu a definuje jejich chování. Obrázek se roztáhne přes veškeré dostupné místo, zatímco tlačítko bude jen tak velké, jak je potřeba. Všimněte si, že jsem u widgetů výslovně nenastavili velikost. GTK to obvykle nepotřebuje, což usnadňuje udělat rozvržení, které vypadá dobře při různých velikostech okna. Následně je box přidán do okna.

note: (itstool) path: item/p
en: We need to define what happens when the user clicks on the button. GTK uses the concept of <em>signals</em>.
cs: Potřebujeme nadefinovat, co se stane, když uživatel klikne na tlačítko. GTK používá koncept <em>signálů</em>.

note: (itstool) path: item/p
en: When the <link href="http://valadoc.org/gtk+-3.0/Gtk.Button.html">button</link> is clicked, it fires the <link href="http://valadoc.org/gtk+-3.0/Gtk.Button.clicked.html"><code>clicked</code></link> signal, which we can connect to some action (defined in a <link href="https://live.gnome.org/Vala/SignalsAndCallbacks">callback</link> method).
cs: Když je kliknuto na <link href="http://valadoc.org/gtk+-3.0/Gtk.Button.html">button</link>, vyšle se signál <link href="http://valadoc.org/gtk+-3.0/Gtk.Button.clicked.html"><code>clicked</code></link>, který může být napojen na nějakou akci (definovanou v metodě <link href="https://live.gnome.org/Vala/SignalsAndCallbacks">zpětného volání</link>).

note: (itstool) path: item/p
en: This is done using the <code>connect</code> method of the button's <code>clicked</code> signal, which in this case tells GTK to call the (yet undefined) <code>on_image_open</code> callback method when the button is clicked. We will define the <em>callback</em> in the next section.
cs: To se udělá pomocí metody <code>connect</code> signálu <code>clicked</code> u tlačítka, což v tomto případě řekne GTK, aby ve chvíli, kdy je na tlačítko kliknuto, zavolalo (zatím nenadefinovanou) metodu zpětného volání <code>on_image_open</code>. <em>Zpětné volání</em> nadefinujeme v další části.

note: (itstool) path: item/p
en: In the callback, we need to access the <code>window</code> and <code>image</code> widgets, which is why we defined them as private members at the top of our class.
cs: Ve zpětném volání potřebujeme přístup k widgetům <code>window</code> a <code>image</code>, což je důvod, proč je definujeme jako soukromé členy na začátku naší třídy.

note: (itstool) path: item/p
en: The last <code>connect</code> call makes sure that the application exits when the window is closed. The code generated by Anjuta called an <code>on_destroy</code> callback method which called <link href="http://www.valadoc.org/gtk+-2.0/Gtk.main_quit.html"><code>Gtk.main_quit</code></link>, but just connecting our signal to <code>main_quit</code> directly is easier. You can delete the <code>on_destroy</code> method.
cs: Poslední volání funkce <code>connect</code> zajistí, že se aplikace ukončí, když je zavřeno okno. Kód, který vygenerovala Anjuta, volá metodu zpětného volání <code>on_destroy</code>, která volá  <link href="http://www.valadoc.org/gtk+-2.0/Gtk.main_quit.html"><code>Gtk.main_quit</code></link>, ale prosté napojení signálu na <code>main_quit</code> je jednodušší. Metodu <code>on_destroy</code> můžete smazat.

note: (itstool) path: section/p
en: We will now define the signal handler for the <code>clicked</code> signal for the button we mentioned before. Add this code after the constructor:
cs: Nyní nadefinujeme obsluhu signálu pro signál <em>clicked</em> tzn. pro tlačítko zmíněné dříve. Přidejte tento kód za konstruktor:

note: (itstool) path: section/p
en: This is a bit complicated, so let's break it down:
cs: Toto je trochu složitější, takže si to pojďme rozebrat:

note: (itstool) path: note/p
en: A signal handler is a type of callback method that is called when a signal is emitted. Here the terms are used interchangeably.
cs: Obsluha signálu je typ metody zpětného volání, která je volána, když je vyslán signál. Běžně se k označní používají oba termíny.

note: (itstool) path: item/p
en: The first argument of the callback method is always the widget that sent the signal. Sometimes other arguments related to the signal come after that, but <em>clicked</em> doesn't have any.
cs: Prvním argumentem metody zpětného volání je vždy widget, který signál vyslal. Někdy za ním může následovat další argument související se signálem, ale <em>clicked</em> žádný nemá.

note: (itstool) path: item/p
en: In this case the <code>button</code> sent the <code>clicked</code> signal, which is connected to the <code>on_open_image</code> callback method:
cs: V tomto případě <code>button</code> vyšle signál <code>clicked</code>, který je napojen na metodu zpětného volání <code>on_open_image</code>:

note: (itstool) path: item/p
en: The <code>on_open_image</code> method takes the button that emitted the signal as an argument:
cs: Metoda <code>on_open_image</code> přebírá jako argument tlačítko, které vyslalo signál:

note: (itstool) path: item/p
en: The next interesting line is where the dialog for choosing the file is created. <link href="http://www.valadoc.org/gtk+-3.0/Gtk.FileChooserDialog.html"><code>FileChooserDialog</code></link>'s constructor takes the title of the dialog, the parent window of the dialog and several options like the number of buttons and their corresponding values.
cs: Dalším zajímavým řádkem je ten, kde je vytvořeno dialogové okno pro výběr souboru. Konstruktor widgetu <link href="http://www.valadoc.org/gtk+-3.0/Gtk.FileChooserDialog.html"><code>FileChooserDialog</code></link> přebírá název do záhlaví dialogového okna, rodičovské okno a několik voleb, jako je počet tlačítek a jim odpovídající hodnoty.

note: (itstool) path: item/p
en: Notice that we are using <link href="http://unstable.valadoc.org/gtk+-3.0/Gtk.Stock.html"><em>stock</em></link> button names from Gtk, instead of manually typing "Cancel" or "Open". The advantage of using stock names is that the button labels will already be translated into the user's language.
cs: Všimněte si, že používáme <link href="http://unstable.valadoc.org/gtk+-3.0/Gtk.Stock.html"><em>standardní</em></link> názvy tlačítek z Gtk, místo abychom ručně psali „Cancel“ nebo „Open“. Výhodou použití standardních názvů je, že popisky tlačítek budou vždy přeloženy do uživatelova jazyka.

note: (itstool) path: item/p
en: The next two lines restrict the <gui>Open</gui> dialog to only display files which can be opened by <em>GtkImage</em>. GtkImage is a widget which displays an image. A filter object is created first; we then add all kinds of files supported by <link href="http://www.valadoc.org/gdk-pixbuf-2.0/Gdk.Pixbuf.html"><code>Gdk.Pixbuf</code></link> (which includes most image formats like PNG and JPEG) to the filter. Finally, we set this filter to be the <gui>Open</gui> dialog's filter.
cs: Následující dva řádky omezí dialogové okno <gui>Open</gui>, aby zobrazovalo jen soubory, které lze otevřít pomocí <code>GtkImage</code>. Nejprve je vytvořen filtr a pak do něj přidáme všechny druhy souborů podporované v <link href="http://www.valadoc.org/gdk-pixbuf-2.0/Gdk.Pixbuf.html"><code>GdkPixbuf</code></link> (což zahrnuje většinu obrázkových formátů, včetně PNG a JPEG). Nakonec tento filtr nastavíme aby byl filtrem dialogového okna <gui>Open</gui>.

note: (itstool) path: item/p
en: <link href="http://www.valadoc.org/gtk+-3.0/Gtk.Dialog.run.html"><code>dialog.run</code></link> displays the <gui>Open</gui> dialog. The dialog will wait for the user to choose an image; when they do, <code>dialog.run</code> will return the <link href="http://www.valadoc.org/gtk+-3.0/Gtk.ResponseType.html">ResponseType</link> value <code>ResponseType.ACCEPT</code> (it would return <code>ResponseType.CANCEL</code> if the user clicked <gui>Cancel</gui>). The <code>switch</code> statement tests for this.
cs: <link href="http://www.valadoc.org/gtk+-3.0/Gtk.Dialog.run.html"><code>dialog.run</code></link> zobrazí dialogové okno <gui>Open</gui>. Dialogové okno bude čekat na uživatele, než si vybere obrázek. Až tak učiní, vrátí <code>dialog.run</code> hodnotu <output>ResponseType.ACCEPT</output> typu <link href="http://www.valadoc.org/gtk+-3.0/Gtk.ResponseType.html">ResponseType</link> nebo by mohl vrátit <output>ResponseType.CANCEL</output>, když uživatel klikne na <gui>Cancel</gui>. Otestujeme to výrazem <code>switch</code>.

note: (itstool) path: item/p
en: Assuming that the user did click <gui>Open</gui>, the next lines get the filename of the image selected by the user, and tell the <code>GtkImage</code> widget to load and display the selected image.
cs: Při předpokladu, že uživatel klikl na <gui>Open</gui>, následující řádek získá název souboru s obrázkem, který uživatel vybral a řekne widgetu <code>GtkImage</code>, aby jej načetl a zobrazil.

note: (itstool) path: item/p
en: Destroying automatically hides the dialog.
cs: Zlikvidováním se dialogové okno automaticky skryje.

note: (itstool) path: section/p
en: If you haven't already done so, choose the <file>src/image-viewer</file> application in the dialog that appears. Finally, hit <gui>Run</gui> and enjoy!
cs: Pokud jste tak ještě neučinili, zvolte aplikaci <file>src/image-viewer</file> v dialogovém okně, které se objeví. Nakonec klikněte na <gui>Spustit</gui> a užijte si ji!

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="image-viewer/image-viewer.vala">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="image-viewer/image-viewer.vala">ukázkovým kódem</link>.

note: (itstool) path: item/p
en: Set it up so that when the window opens it is of a specific size to start off with. For example, 200 X 200 pixels.
cs: Nastavit ji tak, že když se okno otevře, bude mít konkrétní počáteční velikost. Například 200 × 200 pixelů.

note: (itstool) path: credit/name
en: GNOME Documentation Team
cs: Dokumentační tým GNOME

note: (itstool) path: page/title
en: GNOME Developer Platform Demos
cs: Předvedení platformy pro vývojáře GNOME

note: (itstool) path: page/p
en: This guide includes a variety of coding examples, such writing an image viewer or weather application. Each demo comes with code that you can try, and explains how each example works. They are a great way to get started with the GNOME developer platform.
cs: Součástí této příručky jsou různé příklady kódu, jako je naprogramování prohlížeče obrázků nebo aplikace s počasím. U každé ukázky se nachází kód, který můžete vyzkoušet a zároveň je vysvětleno, jak prakticky funguje. To je skvělý způsob, jak začít s platformou pro vývojáře GNOME.

note: (itstool) path: section/title
en: Pick a Language
cs: Výběr programovacího jazyka

note: (itstool) path: section/p
en: These developer demos are available in a range of programming languages. Pick one to get started:
cs: Tyto vývojářské ukázky jsou dostupné v řadě programovacích jazyků. Začněte tím, že si jeden vyberete:

note: (itstool) path: page/title
en: Tutorials, code samples and platform demos in JavaScript
cs: Výuka, ukázky kódu a demonstrace platformy v jazyce JavaScript

note: (itstool) path: section/title
en: Code samples and tutorials
cs: Ukázky kódu a výuka

note: (itstool) path: info/desc
en: A widget which displays text
cs: Widget, který zobrazuje text.

note: (itstool) path: td/p (itstool) path: page/p
en: A simple label
cs: Jednoduchý popisek

note: (itstool) path: page/code
en: #include &lt;gtk/gtk.h&gt;
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *label;
    
      /*Create a window with a title and a default size*/
      window = gtk_application_window_new (app);
      gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (app));
      gtk_window_set_title (GTK_WINDOW (window), "Welcome to GNOME");
      gtk_window_set_default_size (GTK_WINDOW (window), 200,100);
       
      /*Create a label and set its alignment. Setting the line wrap to TRUE makes 
      the label break lines if the text exceeds the widget's size. When set to 
      FALSE the text gets cut off by the edge of the widget*/
      label = gtk_label_new ("Hello GNOME!");
      gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
    
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (label));
    
      gtk_widget_show_all (GTK_WIDGET (window));
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example",G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
      return status;
    }
cs: #include &lt;gtk/gtk.h&gt;
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *label;
    
      /* Vytvoří okno s názvem a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (app));
      gtk_window_set_title (GTK_WINDOW (window), "Welcome to GNOME");
      gtk_window_set_default_size (GTK_WINDOW (window), 200,100);
       
      /* Vytvoří popisek a nastaví jeho zarovnání. Nastavení zalomování řádku na 
         TRUE zajistí, že popisek zalomí řádky, které přesahují velikost widgetu. 
         Když je nastaveno na FALSE, bude text na hraně popisku odříznut */
      label = gtk_label_new ("Hello GNOME!");
      gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
    
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (label));
    
      gtk_widget_show_all (GTK_WIDGET (window));
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example",G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
      return status;
    }

note: (itstool) path: info/desc
en: A label which can contain text
cs: Popisek, který může obsahovat text

note: (itstool) path: page/p
en: A label displaying a friendly message.
cs: Popisek zobrazující přátelskou zprávu.

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class LabelExample {
    
        /* Create the application itself
           This boilerplate code is needed to build any GTK+ application. */
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jslabel',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal initializes menus and builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_height: 100,
                default_width: 200
            });
    
            // Create the label
            this.label = new Gtk.Label({ label: "Hello GNOME!" });
            this._window.add(this.label);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
    
    };
    
    // Run the application
    let app = new LabelExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class LabelExample {
    
        /* Vytvoří vlastní aplikaci
           This boilerplate code is needed to build any GTK+ application. */
        constructor() {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jslabel',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Welcome to GNOME",
                default_height: 100,
                default_width: 200
            });
    
            // Vytvoří popisek
            this.label = new Gtk.Label({ label: "Hello GNOME!" });
            this._window.add(this.label);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
    
    };
    
    // Spustí aplikaci
    let app = new LabelExample ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: A widget that displays a small to medium amount of text
cs: Widget, který zobrazuje malé až střední množství textu.

note: (itstool) path: section/p
en: Another way to obtain what we have in the example is to create the label as an instance of another class and add it to the instance of <code>MyWindow</code> in the <code>do_activate(self)</code> method:
cs: Jiným způsobem, jak získat to, co máme v příkladu, je vytvořit popisek jako instanci jiné třídy a přidat jej do instance <code>MyWindow</code> v metodě <code>do_activate(self)</code>:

note: (itstool) path: note/p
en: The highlighted lines indicate code that is different from the previous snippet.
cs: Zvýrazněné řádky označují kód, který se liší od předchozího úryvku.

note: (itstool) path: section/code
en: 
    # a class to define a window
    class MyWindow(Gtk.ApplicationWindow):
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(200, 100)
    
    # a class to define a label
    <e:hi>
    class MyLabel(Gtk.Label):
        def __init__(self):
            Gtk.Label.__init__(self)
            self.set_text("Hello GNOME!")
    </e:hi>
    
    class MyApplication(Gtk.Application):
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            # create an instance of MyWindow
            win = MyWindow(self)
    
            # create an instance of MyLabel
    <e:hi>
            label = MyLabel()
    </e:hi>
            # and add it to the window
    <e:hi>
            win.add(label)
    </e:hi>
            # show the window and everything on it
            win.show_all()
cs: 
    # Třída pro definici okna
    class MyWindow(Gtk.ApplicationWindow):
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Welcome to GNOME", application=app)
            self.set_default_size(200, 100)
    
    # Třída pro definici popisku
    <e:hi>
    class MyLabel(Gtk.Label):
        def __init__(self):
            Gtk.Label.__init__(self)
            self.set_text("Hello GNOME!")
    </e:hi>
    
    class MyApplication(Gtk.Application):
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            # Vytvoří instanci MyWindow
            win = MyWindow(self)
    
            # Vytvoří instanci MyLabel
    <e:hi>
            label = MyLabel()
    </e:hi>
            # a přidá ji do okna
    <e:hi>
            win.add(label)
    </e:hi>
            # Zobrazí okno a vše v něm
            win.show_all()

note: (itstool) path: section/title
en: Useful methods for a Label widget
cs: Užitečné metody pro widget Label

note: (itstool) path: note/p
en: An explanation of how to work with strings in GTK+ can be found in <link xref="strings.py"/>.
cs: Vysvětlení, jak se v GTK+ pracuje s řetězci, najdete v kapitole <link xref="strings.py"/>.

note: (itstool) path: item/p
en: <code>set_line_wrap(True)</code> breaks lines if the text of the label exceeds the size of the widget.
cs: <code>set_line_wrap(True)</code> zalamuje řádky v případě, že text popisku přesáhne velikost widgetu.

note: (itstool) path: item/p
en: <code>set_justify(Gtk.Justification.LEFT)</code> (or <code>Gtk.Justification.RIGHT, Gtk.Justification.CENTER, Gtk.Justification.FILL</code>) sets the alignment of the lines in the text of the label relative to each other. The method has no effect on a single-line label.
cs: <code>set_justify(Gtk.Justification.LEFT)</code> (nebo <code>Gtk.Justification.RIGHT, Gtk.Justification.CENTER, Gtk.Justification.FILL</code>) nastaví zarovnání řádků v textu popisku relativně vůči sobě. Tato metoda nemá žádný vliv na popisek s jedním řádkem.

note: (itstool) path: item/p
en: For decorated text we can use <code>set_markup("text")</code>, where <code>"text"</code> is a text in the <link href="http://developer.gnome.org/pango/stable/PangoMarkupFormat.html">Pango Markup Language</link>. An example:
cs: Ke zdobení textu můžeme použít <code>set_markup("text")</code>, kde <code>"text"</code> je text ve <link href="http://developer.gnome.org/pango/stable/PangoMarkupFormat.html">značkovacím jazyce Pango</link>. Příklad:

note: (itstool) path: item/code
en: 
    label.set_markup("Text can be &lt;small&gt;small&lt;/small&gt;, &lt;big&gt;big&lt;/big&gt;, "
                     "&lt;b&gt;bold&lt;/b&gt;, &lt;i&gt;italic&lt;/i&gt; and even point to somewhere "
                     "on the &lt;a href=\"http://www.gtk.org\" "
                     "title=\"Click to find out more\"&gt;internet&lt;/a&gt;.")
cs: 
    label.set_markup("Text can be &lt;small&gt;small&lt;/small&gt;, &lt;big&gt;big&lt;/big&gt;, "
                     "&lt;b&gt;bold&lt;/b&gt;, &lt;i&gt;italic&lt;/i&gt; and even point to somewhere "
                     "in the &lt;a href=\"http://www.gtk.org\" "
                     "title=\"Click to find out more\"&gt;internets&lt;/a&gt;.")

note: (itstool) path: license/p
en: This work is licensed under a <_:link-1/>. As a special exception, the copyright holders give you permission to copy, modify, and distribute the example code contained in this documentation under the terms of your choosing, without restriction.
cs: Tato práce je šířena pod licencí <_:link-1/>. Jako zvláštní výjimka se vám držitelem autorských práv uděluje svolení kopírovat, upravovat a šířit ukázkový kód obsažený v tomto dokumentu za podmínek, které si zvolíte, bez dalších omezení.

note: (itstool) path: info/desc
en: Legal information.
cs: Právní informace.

note: (itstool) path: page/title
en: License
cs: Licence

note: (itstool) path: page/p
en: This work is distributed under a CreativeCommons Attribution-Share Alike 3.0 Unported license.
cs: Tato práce je šířena pod licencí CreativeCommons Attribution-Share Alike 3.0 Unported license.

note: (itstool) path: page/p
en: You are free:
cs: Můžete volně:

note: (itstool) path: item/title
en: <em>To share</em>
cs: <em>Sdílet</em>"

note: (itstool) path: item/p
en: To copy, distribute and transmit the work.
cs: Kopírovat, šířit a rozesílat dílo.

note: (itstool) path: item/title
en: <em>To remix</em>
cs: <em>Měnit</em>

note: (itstool) path: item/p
en: To adapt the work.
cs: Přizpůsobovat dílo.

note: (itstool) path: page/p
en: Under the following conditions:
cs: Za následujících podmínek:

note: (itstool) path: item/title
en: <em>Attribution</em>
cs: <em>Označení</em>

note: (itstool) path: item/p
en: You must attribute the work in the manner specified by the author or licensor (but not in any way that suggests that they endorse you or your use of the work).
cs: Musíte dílo označit v souladu s požadavky autora nebo licence (ale ne žádným způsobem, který předpokládá, že podporují vás nebo vaše použití díla).

note: (itstool) path: item/title
en: <em>Share Alike</em>
cs: <em>Stejné sdílení</em>

note: (itstool) path: item/p
en: If you alter, transform, or build upon this work, you may distribute the resulting work only under the same, similar or a compatible license.
cs: Pokud dílo změníte, převedete nebo na něm založíte jiné, můžete výsledek této práce šířit pouze pod stejnou, podobnou nebo kompatibilní licencí.

note: (itstool) path: page/p
en: For the full text of the license, see the <link href="http://creativecommons.org/licenses/by-sa/3.0/legalcode">CreativeCommons website</link>, or read the full <link href="http://creativecommons.org/licenses/by-sa/3.0/">Commons Deed</link>.
cs: Text licence v plném znění najdete na <link href="http://creativecommons.org/licenses/by-sa/3.0/legalcode">webových stránkách CreativeCommons</link> nebo si přečtěte <link href="http://creativecommons.org/licenses/by-sa/3.0/">výtah dokumentu pro neprávníky</link>.

note: (itstool) path: note/p
en: As a special exception, the copyright holders give you permission to copy, modify, and distribute the example code contained in this documentation under the terms of your choosing, without restriction.
cs: Jako zvláštní výjimka se vám držitelem autorských práv uděluje svolení kopírovat, upravovat a šířit ukázkový kód obsažený v tomto dokumentu za podmínek, které si zvolíte, bez dalších omezení.

note: (itstool) path: info/desc
en: Create buttons bound to a URL
cs: Tlačítko svázané s adresou URL

note: (itstool) path: page/p
en: This button links to the GNOME live webpage.
cs: Toto tlačítko odkazuje na webovou stránku GNOME live.

note: (itstool) path: info/desc
en: A button that links to a web page
cs: Tlačítko, které odkazuje na webovou stránku

note: (itstool) path: page/p
en: A button that links to live.gnome.org.
cs: Tlačítko, které odkazuje na live.gnome.org.

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class LinkButtonExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jslinkbutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
             });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal initializes menus and builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
        this._window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                     window_position: Gtk.WindowPosition.CENTER,
                                                     title: "GNOME LinkButton",
                                                     default_height: 50,
                                                     default_width: 250 });
    
            // Create the LinkButton and have it link to live.gnome.org
            this.LinkButton = new Gtk.LinkButton ({label: "Link to GNOME live!",
                                   uri: "http://live.gnome.org"});
            this._window.add (this.LinkButton);
    
        // Show the window and all child widgets
        this._window.show_all();
        }
    };
    
    // Run the application
    let app = new LinkButtonExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class LinkButtonExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jslinkbutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
             });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
        // Vytvoří okno aplikace
        this._window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                     window_position: Gtk.WindowPosition.CENTER,
                                                     title: "GNOME LinkButton",
                                                     default_height: 50,
                                                     default_width: 250 });
    
            // Vytvoří LinkButton a nastaví mu odkaz na live.gnome.org
            this.LinkButton = new Gtk.LinkButton ({label: "Link to GNOME live!",
                                   uri: "http://live.gnome.org"});
            this._window.add (this.LinkButton);
    
        // Zobrazí okno a všechny jeho synovské widgety
        this._window.show_all();
        }
    };
    
    // Spustí aplikaci
    let app = new LinkButtonExample ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: A button bound to an URL
cs: Tlačítko svázané s URL

note: (itstool) path: page/p
en: A button that links to a web page.
cs: Tlačítko, které odkazuje na webovou stránku.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # a window
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="GNOME LinkButton", application=app)
            self.set_default_size(250, 50)
    
            # a linkbutton pointing to the given URI
            button = Gtk.LinkButton(uri="http://live.gnome.org")
            # with given text
            button.set_label("Link to GNOME live!")
    
            # add the button to the window
            self.add(button)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # Okno
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="GNOME LinkButton", application=app)
            self.set_default_size(250, 50)
    
            # LinkButton odkazující na zadanou adresu URI
            button = Gtk.LinkButton(uri="http://live.gnome.org")
            # se zadaným textem
            button.set_label("Link to GNOME live!")
    
            # Přidá tlačítko do okna
            self.add(button)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a LinkButton widget
cs: Užitečné metody pro widget LinkButton

note: (itstool) path: item/p
en: <code>get_visited()</code> returns the 'visited' state (<code>True</code> or <code>False</code>) of the URI where the LinkButton points. The button becomes visited when it is clicked.
cs: <code>get_visited()</code> vrací stav vlastnosti <code>visited</code> (navštíveno) jako <code>True</code> nebo <code>False</code> pro adresu URI, na kterou <code>LinkButton</code> ukazuje. Tlačítko se stane „navštíveným“, když se na něj klikne.

note: (itstool) path: item/p
en: <code>set_visited(True)</code> sets the 'visited' state of the URI where the LinkButton points as <code>True</code> (analogously for <code>False</code>).
cs: <code>set_visited(True)</code> nastaví stav vlastnosti <code>visited</code> (navštíveno) pro adresu URI, na kterou <code>LinkButton</code> ukazuje na <code>True</code> (obdobně pro <code>False</code>).

note: (itstool) path: item/p
en: Each time the button is clicked, the signal <code>"activate-link"</code> is emitted. For an explanation of signals and callback functions, see <link xref="signals-callbacks.py"/>.
cs: Pokaždé, když je kliknuto na tlačítko, je vyslán signál <code>"activate-link"</code>. Vysvětlení signálů a funkcí zpětného volání viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: page/p
en: This button links to GNOME live.
cs: Toto tlačítko odkazuje na web GNOME live.

note: (itstool) path: page/code
en: /* This is the application. */
    public class MyApplication : Gtk.Application {
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    
    		/* Create the window of this application and child widget and show all the things. */
    		var window = new Gtk.ApplicationWindow (this);
    		window.set_default_size (250, 50);
    		window.title = "GNOME LinkButton";
    
    		var linkbutton = new Gtk.LinkButton.with_label ("http://live.gnome.org", "Link to GNOME live!");
    
    		window.add (linkbutton);
    		window.show_all ();
    	}
    }
    
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Toto je aplikace. */
    public class MyApplication : Gtk.Application {
    	/* Přepíše signál "activate" z GLib.Application. */
    	protected override void activate () {
    
    		/* Vytvoří okno této aplikace a synovský widget a vše zobrazí. */
    		var window = new Gtk.ApplicationWindow (this);
    		window.set_default_size (250, 50);
    		window.title = "GNOME LinkButton";
    
    		var linkbutton = new Gtk.LinkButton.with_label ("http://live.gnome.org", "Link to GNOME live!");
    
    		window.add (linkbutton);
    		window.show_all ();
    	}
    }
    
    /* main vytvoří a spustí aplikaci. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

[ctx: text]
note: (itstool) path: info/title
en: Magic mirror (Vala)
cs: Magické zrcadlo (Vala)

note: (itstool) path: info/desc
en: Use your webcam as a mirror using the GStreamer framework and GTK+
cs: Jak použít svoji webovou kameru jako zrcadlo pomocí základního rámce GStreamer a GTK+.

note: (itstool) path: page/title
en: Magic mirror
cs: Magické zrcadlo

note: (itstool) path: synopsis/p
en: <em>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?</em>
cs: <em>Spadlo vám ze zdi zrcadlo a rozbilo se na tisíc kousků a vy se zrovna nutně potřebujete oholit nebo si udělat make-up! A máte jen 15 minut, než vám pojede autobus do práce. Co teď?</em>

note: (itstool) path: synopsis/p
en: In this tutorial, we're going to make a program which lets you use your webcam as a mirror. You will learn how to:
cs: V této lekci napíšeme program, který vám umožní používat webovou kameru jako zrcadlo. Naučíte se tyto věci:

note: (itstool) path: item/p
en: Create a GTK+ application
cs: Vytvořit aplikaci GTK+

note: (itstool) path: item/p
en: Access your webcam using GStreamer and embed the result into a window
cs: Přistupovat k webové kameře pomocí knihovny GStreamer a výsledek vložit do okna

note: (itstool) path: item/p
en: Grab photos off your webcam
cs: Pořídit fotografie vaší webovou kamerou

note: (itstool) path: item/p
en: Installed copies of GTK, GStreamer, and a Vala compiler
cs: Nainstalované kopie knihoven GTK a Gstreamer a kompilátoru jazyka Vala

note: (itstool) path: item/p
en: Basic knowledge of an object-oriented programming language
cs: Základní znalosti o objektově orientovaných programovacích jazycích

note: (itstool) path: item/p
en: 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>magic-mirror</file> as project name and directory.
cs: Na kartě <gui>Vala</gui> zvolte <gui>GTK+ (jednoduchý)</gui>. Klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>maginc-mirror</file>.

note: (itstool) path: item/p
en: 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.
cs: Ujistěte se, že <gui>Použít GtkBuilder k tvorbě uživatelského rozhraní</gui> je vypnuto, protože jej chceme v této lekci vytvořit ručně. Na použití návrháře uživatelského rozhraní se podívejte do lekce <link xref="guitar-tuner.vala">Kytarová ladička</link>.

note: (itstool) path: item/p
en: 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.
cs: Ujistěte se, že <gui>Konfigurovat externí balíčky</gui> je zapnuto. Na následující stránce vyberte v seznamu <em>gstreamer-0.10</em>, aby se knihovna GStreamer zahrnula do vašeho projektu.

note: (itstool) path: item/p
en: 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:
cs: Klikněte na <gui>Použít</gui> a vytvoří se vám projekt. Otevřete <file>src/magic_mirror.vala</file> na kartě <gui>Projekt</gui> nebo <gui>Soubor</gui>. Měli byste vidět kód, který začíná řádky:

note: (itstool) path: section/p
en: The code loads an (empty) window and shows it. More details are given below; skip this list if you understand the basics:
cs: Kód načte (prázdné) okno ze souboru s popisem uživatelského rozhraní a zobrazí jej. Dále to podrobněji rozebereme. Pokud jste již pochopili základy, tak tento seznam můžete přeskočit:

note: (itstool) path: item/p
en: 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.
cs: Konstruktor třídy <code>Main</code> vytvoří nové okno a nastaví jeho název pro záhlaví. Potom je okno zobrazeno a je napojen signál, který ukončí aplikaci, když je okno zavřeno. Více o signálech si řekneme později.

note: (itstool) path: item/p
en: 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).
cs: Statická funkce <code>main</code> se spustí jako výchozí, když spustíte aplikaci napsanou v jazyce Vala. Volá pár funkcí, které vytvoří třídu <code>Main</code> a nastaví a spustí aplikaci. Funkce <code>Gtk.main</code> spustí hlavní smyčku GTK, která spustí uživatelské rozhraní a začne naslouchat událostem (jako je kliknutí nebo zmáčknutí klávesy).

note: (itstool) path: section/title
en: Access the webcam video stream with GStreamer
cs: Přístup pomocí GStreamer k vysílání videa z webové kamery

note: (itstool) path: section/p
en: The GStreamer multimedia framework is able to handle video from webcams. Let's add GStreamer to our application and so we can access the video stream.
cs: Základní multimediální konstrukce GStreamer umí zpracovávat video z webových kamer. Pojďme přidat GStreamer do naší aplikace a můžeme pak přistupovat k videovysílání.

note: (itstool) path: item/p
en: First we remove the window we created before because GStreamer will take care of showing the picture on screen.
cs: Nejprve odstraníme okno, které jsem před tím vytvořili, protože GStreamer se o zobrazení obrázku na obrazovce postará.

note: (itstool) path: item/p
en: Now we are creating a GStreamer element which accesses our webcam. We are using the Camerabin element, which is an all-in-one camera element and is capable of taking photos, videos, applying effects and much more. Perfect for our use case! With <code>this.camerabin.set_state (Gst.State.PLAYING)</code> we tell the GStreamer pipeline we just created to start playing. Easy, no?
cs: Nyní vytvoříme prvek GStreamer, který zajistí přístup k webové kameře. Použijeme prvek Camerabin, což je prvek „vše v jednom“ – umí pořizovat fotky, videonahrávky, na vše nasadit efekty a mnoho dalšího. Pro naše použití přímo ideální. Pomocí <code>this.camerabin.set_state (Gst.State.PLAYING)</code> řekneme rouře, že to co jsme právě vytvořili, má začít s přehráváním. Snadné ne?

note: (itstool) path: item/p
en: Of course it is also possible to integrate the video more tightly into other windows but that is an advanced topic that includes some details of the X Window System we will omit here.
cs: Mohli bychom samozřejmě video integrovat těsněji s dalšími okny, ale to je již pokročilé téma zahrnující podrobnosti o systému X Window, do čehož se zde pouštět nebudeme.

note: (itstool) path: item/p
en: 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.
cs: Kód znovu přeložte a spusťte. Měli byste skončit se dvěma okny. V dalším kroku začleníme video do okna GTK+.

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="magic-mirror/magic-mirror.vala">reference code</link>. There is also a more <link href="magic-mirror/magic-mirror-advanced.vala">extensive implementation</link> that embeds the window into a regular Gtk.Window which involves some advanced techniques, and adds buttons to start/stop the picture.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="magic-mirror/magic-mirror.vala">ukázkovým kódem</link>. Je zde i <link href="magic-mirror/magic-mirror-advanced.vala">rozsáhlejší realizace</link>, která vkládá okno do běžného Gtk.Windows, což zahrnuje některé pokročilé techniky a přidává tlačítka pro spuštění/zastavení obrázků.

note: (itstool) path: section/p
en: To find out more about the Vala programming language you might want to check out the <link href="http://live.gnome.org/Vala/Tutorial">Vala Tutorial</link>.
cs: Jestli si chcete o programování v jazyce Vala najít něco více, můžete se podívat na <link href="http://live.gnome.org/Vala/Tutorial">výuku jazyka Vala</link>.

note: (itstool) path: section/title
en: Conclusion
cs: Závěr

note: (itstool) path: section/p
en: That's it, you have managed to create a full-featured webcam photo application in 15 minutes. Now you can shave your beard off or add some makeup to your beautiful face, right before having a beautiful day at your workplace, where you can impress your friends and colleagues with an awesome application you just made in 15 minutes.
cs: A je to, podařilo se vám vytvořit plně funkční aplikaci s webovou kamerou během 15 minut. Nyní se můžete oholit a udělat si make-up na svoji krásnou tvář před tím, něž strávíte hezký den ve své práci, kde můžete oslnit své přátele a kolegy úžasnou aplikací, kterou jste právě za 15 minut stvořili.

note: (itstool) path: info/desc
en: A widget which holds GtkMenuItem widgets
cs: Widget, který sdružuje widgety GtkMenuItem.

note: (itstool) path: page/p
en: A MenuBar created using XML and GtkBuilder.
cs: MenuBar vytvořený pomocí XML a GtkBuilder.

note: (itstool) path: note/p
en: For a more in-depth look at this sample, please do not hesitate to check out the <link xref="menubar.vala">Vala MenuBar</link> and/or <link xref="menubar.py">Python MenuBar</link> tutorials.
cs: Kvůli hlubšímu prozkoumání této ukázky se neváhejte podívat i na lekce <link xref="menubar.vala">MenuBar (Vala)</link> a <link xref="menubar.py">MenuBar (Python)</link>.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Callback function for the "copy" action */
    static void
    copy_callback (GSimpleAction *simple,
                GVariant      *parameter,
                gpointer       user_data)
    {
       g_print ("\"Copy\" activated\n");
    }
    
    
    
    /* Callback function for the "paste" action */
    static void
    paste_callback (GSimpleAction *simple,
                GVariant      *parameter,
                gpointer       user_data)
    {
       g_print ("\"Paste\" activated\n");
    }
    
    
    
    /* Callback function for the "shape" action */
    static void
    shape_callback (GSimpleAction *simple,
                GVariant      *parameter,
                gpointer       user_data)
    {
       /* We first gather the value of the GVariant instance with a string type.
        * The overall goal here is to see if shape is set to line, triangle, etc,
        * and put that value within the variable "answer".
        */
       const gchar *answer = g_variant_get_string (parameter, NULL);
       g_printf ("Shape is set to %s.\n", answer);
       /* Note that we set the state of the action */
       g_simple_action_set_state (simple, parameter);
    }
    
    
    
    /* Callback function in which closes the about_dialog created below */
    static void
    on_close (GtkDialog *dialog,
              gint       response_id,
              gpointer   user_data)
    {
      gtk_widget_destroy (GTK_WIDGET (dialog));
    }
    
    
    
    /* Callback function for the about action (see aboutdialog.c example) */
    static void
    about_callback (GSimpleAction *simple,
                GVariant      *parameter,
                gpointer       user_data)
    {
       GtkWidget *about_dialog;
    
       about_dialog = gtk_about_dialog_new ();
    
       const gchar *authors[] = {"GNOME Documentation Team", NULL};
       const gchar *documenters[] = {"GNOME Documentation Team", NULL};
    
       /* Fill in the about_dialog with the desired information */
       gtk_about_dialog_set_program_name (GTK_ABOUT_DIALOG (about_dialog), "AboutDialog Example");
       gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG (about_dialog), "Copyright \xc2\xa9 2012 GNOME Documentation Team");
       gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG (about_dialog), authors);
       gtk_about_dialog_set_documenters (GTK_ABOUT_DIALOG (about_dialog), documenters);
       gtk_about_dialog_set_website_label (GTK_ABOUT_DIALOG (about_dialog), "GNOME Developer Website");
       gtk_about_dialog_set_website (GTK_ABOUT_DIALOG (about_dialog), "http://developer.gnome.org");
    
       /* The "response" signal is emitted when the dialog receives a delete event,
        * therefore we connect that signal to the on_close callback function
        * created above.
        */
       g_signal_connect (GTK_DIALOG (about_dialog), "response",
                        G_CALLBACK (on_close), NULL);
    
       /* Show the about dialog */
       gtk_widget_show (about_dialog);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
    
      GSimpleAction *copy_action;
      GSimpleAction *paste_action;
      GSimpleAction *shape_action;
      GSimpleAction *about_action;
    
      /* Create a window with a title and a default size */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "MenuBar Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
    
      /* Begin creating the "copy" action.
       * Note that it is an action without a state.
       */
      copy_action = g_simple_action_new ("copy", NULL);
      /* Connected to a callback function */
      g_signal_connect (copy_action, "activate", G_CALLBACK (copy_callback),
                        GTK_WINDOW (window));
      /* Added to the window */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (copy_action));
    
      /* Begin creating the "paste" action.
       * Note that it is an action without a state.
       */
      paste_action = g_simple_action_new ("paste", NULL);
      /* Connect the action to a callback function */
      g_signal_connect (paste_action, "activate", G_CALLBACK (paste_callback),
                        GTK_WINDOW (window));
      /* Add it to the window */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (paste_action));
    
      /* Begin creating the "shape" action.
       * Note that it is an action with a state.
       * First we state that the parameter type of the simple action is a string.
       * When using g_variant_type_new, it is appropriate to free the return value
       * once you're done with it.
       */
      GVariantType *type_string = g_variant_type_new ("s");
      /* parameters for the g_simple_action_new_stateful are: (name, parameter type,
       * initial state).
       */
      shape_action = g_simple_action_new_stateful ("shape", type_string,
                                                   g_variant_new_string ("line"));
      /* Connect the action to a callback function */
      g_signal_connect (shape_action, "activate", G_CALLBACK (shape_callback),
                        GTK_WINDOW (window));
      /* Add it to the window */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (shape_action));
      g_variant_type_free (type_string);
    
      /* Begin creating the "about" action.
       * Note that it is an action without a state.
       */
      about_action = g_simple_action_new ("about", NULL);
      /* Connect the action to a callback function */
      g_signal_connect (about_action, "activate", G_CALLBACK (about_callback),
                        GTK_WINDOW (window));
      /* Add it to the window */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (about_action));
    
      gtk_widget_show_all (window);
    }
    
    
    
    /* Callback function for the "new" action */
    static void
    new_callback (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
      g_print ("You clicked \"New\"\n");
    }
    
    
    
    /* Callback function for the "quit" action */
    static void
    quit_callback (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
      GApplication *application = user_data;
    
      g_print ("You clicked \"Quit\"\n");
      g_application_quit (application);
    }
    
    
    
    /* Callback function for the "state" action */
    static void
    state_callback (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
       /* The two possibilities in this case for the "answer" variable are either
        * "on" or "off".
        */
       const gchar *answer = g_variant_get_string (parameter, NULL);
       /* We print the information to the user */
       g_printf ("State is set to %s.\n", answer);
       /* Note that we set the state of the action */
       g_simple_action_set_state (simple, parameter);
    }
    
    
    
    /* Callback function for the "awesome" action */
    static void
    awesome_callback (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
      GVariant *action_state = g_action_get_state (G_ACTION (simple));
      gboolean active = g_variant_get_boolean (action_state);
      GVariant *new_state = g_variant_new_boolean (!active);
      /* Set the new state for the action.
       * (Keeps track of whether it was last checked or unchecked).
       */
      g_simple_action_set_state (simple, new_state);
    
      if (active)
         g_print ("You unchecked \"Awesome\"\n");
      else
         g_print ("You checked \"Awesome\"\n");
    }
    
    
    
    /* Startup function for the menu we are creating in this sample */
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      /* Initialize variables */
      GSimpleAction *new_action;
      GSimpleAction *quit_action;
      GSimpleAction *state_action;
      GSimpleAction *awesome_action;
    
      GtkBuilder *builder;
    
      GError *error = NULL;
    
      /* Begin creating the "new" action.
       * Note that it is an action without a state.
       */
      new_action = g_simple_action_new ("new", NULL);
      g_signal_connect (new_action, "activate", G_CALLBACK (new_callback), app);
      /* It is added to the overall application */
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (new_action));
    
      /* Begin creating the "quit" action.
       * Note that it is an action without a state.
       */
      quit_action = g_simple_action_new ("quit", NULL);
      g_signal_connect (quit_action, "activate", G_CALLBACK (quit_callback), app);
      /* It is added to the overall application */
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
    
      /* Begin creating the "state" action.
       * Note that it is an action with a state.
       */
      GVariantType *type_string2 = g_variant_type_new ("s");
      state_action = g_simple_action_new_stateful ("state", type_string2,
                                                   g_variant_new_string ("off"));
      g_signal_connect (state_action, "activate", G_CALLBACK (state_callback), app);
      /* It is added to the overall application */
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (state_action));
      g_variant_type_free (type_string2);
    
      /* Begin creating the "awesome" action.
       * Note that it is an action with a state.
       */
      awesome_action = g_simple_action_new_stateful ("awesome", NULL, g_variant_new_boolean (FALSE));
      g_signal_connect (awesome_action, "activate", G_CALLBACK (awesome_callback), app);
      /* It is added to the overall application */
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (awesome_action));
    
      /* A builder to add the User Interface designed with GLADE to the grid: */
      builder = gtk_builder_new ();
      /* Get the file (if it is there):
       * Note: you must make sure that the file is in the current directory for
       * this to work. The function used here returns a non-null value within
       * our variable "error" if an error is indeed found.
       */
      gtk_builder_add_from_file (builder, "menubar.ui", &amp;error);
      if (error != NULL) {
         g_print ("%s\n", error-&gt;message);
         g_error_free (error);
      }
    
      /* Extract the menubar */
      GObject *menubar = gtk_builder_get_object (builder, "menubar");
      gtk_application_set_menubar (GTK_APPLICATION (app), G_MENU_MODEL (menubar));
    
      /* Extract the appmenu */
      GObject *appmenu = gtk_builder_get_object (builder, "appmenu");
      gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (appmenu));
    }
    
    
    
    /* Startup function for the application */
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Funkce zpětného volání pro akci "copy" */
    static void
    copy_callback (GSimpleAction *simple,
                GVariant      *parameter,
                gpointer       user_data)
    {
       g_print ("\"Copy\" activated\n");
    }
    
    
    
    /* Funkce zpětného volání pro akci "paste" */
    static void
    paste_callback (GSimpleAction *simple,
                GVariant      *parameter,
                gpointer       user_data)
    {
       g_print ("\"Paste\" activated\n");
    }
    
    
    
    /* Funkce zpětného volání pro akci "shape" */
    static void
    shape_callback (GSimpleAction *simple,
                GVariant      *parameter,
                gpointer       user_data)
    {
       /* We first gather the value of the GVariant instance with a string type.
        * The overall goal here is to see if shape is set to line, triangle, etc,
        * and put that value within the variable "answer".
        */
       const gchar *answer = g_variant_get_string (parameter, NULL);
       g_printf ("Shape is set to %s.\n", answer);
       /* Všimněte si, že zde nastavíme stav akce */
       g_simple_action_set_state (simple, parameter);
    }
    
    
    
    /* Funkce zpětného vulání, ve které zavíráme about_dialog vytvořený dále */
    static void
    on_close (GtkDialog *dialog,
              gint       response_id,
              gpointer   user_data)
    {
      gtk_widget_destroy (GTK_WIDGET (dialog));
    }
    
    
    
    /* Funkce zpětného volání pro akci "about" (viz příklad aboutdialog.c) */
    static void
    about_callback (GSimpleAction *simple,
                GVariant      *parameter,
                gpointer       user_data)
    {
       GtkWidget *about_dialog;
    
       about_dialog = gtk_about_dialog_new ();
    
       const gchar *authors[] = {"GNOME Documentation Team", NULL};
       const gchar *documenters[] = {"GNOME Documentation Team", NULL};
    
       /* Vyplní about_dialog požadovanými informacemi */
       gtk_about_dialog_set_program_name (GTK_ABOUT_DIALOG (about_dialog), "AboutDialog Example");
       gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG (about_dialog), "Copyright \xc2\xa9 2012 GNOME Documentation Team");
       gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG (about_dialog), authors);
       gtk_about_dialog_set_documenters (GTK_ABOUT_DIALOG (about_dialog), documenters);
       gtk_about_dialog_set_website_label (GTK_ABOUT_DIALOG (about_dialog), "GNOME Developer Website");
       gtk_about_dialog_set_website (GTK_ABOUT_DIALOG (about_dialog), "http://developer.gnome.org");
    
       /* Signál "response" je vyslán, když dialogové okno přijme událost "delete",
        * proto jsme tento signál napojili na funkci zpětného volání on_close vytvořenou
        * výše.
        */
       g_signal_connect (GTK_DIALOG (about_dialog), "response",
                        G_CALLBACK (on_close), NULL);
    
       /* Zobrazí about_dialog */
       gtk_widget_show (about_dialog);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
    
      GSimpleAction *copy_action;
      GSimpleAction *paste_action;
      GSimpleAction *shape_action;
      GSimpleAction *about_action;
    
      /* Vytvoří okno s názvem a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "MenuBar Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
    
      /* Začne vytvářet akci "copy"
       * Všimněte si, že je bezstavová
       */
      copy_action = g_simple_action_new ("copy", NULL);
      /* Napojí akci na funkci zpětného volání */
      g_signal_connect (copy_action, "activate", G_CALLBACK (copy_callback),
                        GTK_WINDOW (window));
      /* Přidá ji do okna */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (copy_action));
    
      /* Začně vytvářet akci "paste"
       * Všimněte si, že je bezstavová
       */
      paste_action = g_simple_action_new ("paste", NULL);
      /* Napojí akci na funkci zpětného volání */
      g_signal_connect (paste_action, "activate", G_CALLBACK (paste_callback),
                        GTK_WINDOW (window));
      /* Přidá ji do okna */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (paste_action));
    
      /* Začne vytvářet akci "shape"
       * Všimněte si, že tato akce je stavová
       * Nejprve uveďme, že typ parametru je pro jednoduchou akci řetězec.
       * Když používáme g_variant_type_new, je potřeba vrácenou hodnotu
       * příslušně uvolnit, když jsem s ní hotovi.
       */
      GVariantType *type_string = g_variant_type_new ("s");
      /* Parametry pro g_simple_action_new_stateful jsou: název, typ parametru,
       * počáteční stav
       */
      shape_action = g_simple_action_new_stateful ("shape", type_string,
                                                   g_variant_new_string ("line"));
      /* Napojí akci na funkci zpětného volání */
      g_signal_connect (shape_action, "activate", G_CALLBACK (shape_callback),
                        GTK_WINDOW (window));
      /* Přidá ji do okna */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (shape_action));
      g_variant_type_free (type_string);
    
      /* Začne vytvářet akci "about"
       * Všimně te si, že tato akce je stavová
       */
      about_action = g_simple_action_new ("about", NULL);
      /* Napojí akci na funkci zpětného volání */
      g_signal_connect (about_action, "activate", G_CALLBACK (about_callback),
                        GTK_WINDOW (window));
      /* Přidá ji do okna */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (about_action));
    
      gtk_widget_show_all (window);
    }
    
    
    
    /* Funkce zpětného volání pro akci "new" */
    static void
    new_callback (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
      g_print ("You clicked \"New\"\n");
    }
    
    
    
    /* Funkce zpětného volání pro akci "quit" */
    static void
    quit_callback (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
      GApplication *application = user_data;
    
      g_print ("You clicked \"Quit\"\n");
      g_application_quit (application);
    }
    
    
    
    /* Funkce zpětného volání pro akci "state" */
    static void
    state_callback (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
       /* Dvě možnosti v tomto případě pro proměnnou "answer" jsou
        * "on" nebo "off"
        */
       const gchar *answer = g_variant_get_string (parameter, NULL);
       /* Vypíšeme informace uživateli */
       g_printf ("State is set to %s.\n", answer);
       /* Všimněte si, že zde nastavíme stav akce */
       g_simple_action_set_state (simple, parameter);
    }
    
    
    
    /* Funkce zpětného volání pro akci "awesome" */
    static void
    awesome_callback (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
      GVariant *action_state = g_action_get_state (G_ACTION (simple));
      gboolean active = g_variant_get_boolean (action_state);
      GVariant *new_state = g_variant_new_boolean (!active);
      /* Nastaví nový stav pro akci
       * (uchovává znalost, jestli naposledy bylo zaškrtnuto nebo nezaškrtnuto)
       */
      g_simple_action_set_state (simple, new_state);
    
      if (active)
         g_print ("You unchecked \"Awesome\"\n");
      else
         g_print ("You checked \"Awesome\"\n");
    }
    
    
    
    /* Spouštěcí funkce pro nabídku, kterou jsme vytvořili v tomto příkladu */
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      /* Inicializace proměnných */
      GSimpleAction *new_action;
      GSimpleAction *quit_action;
      GSimpleAction *state_action;
      GSimpleAction *awesome_action;
    
      GtkBuilder *builder;
    
      GError *error = NULL;
    
      /* Začne vytvářet akci "new"
       * Všimněte si, že je bezstavová
       */
      new_action = g_simple_action_new ("new", NULL);
      g_signal_connect (new_action, "activate", G_CALLBACK (new_callback), app);
      /* Přidá se pro celou aplikaci */
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (new_action));
    
      /* Začne vytvářet akci "quit"
       * Všimněte si, že je bezstavová
       */
      quit_action = g_simple_action_new ("quit", NULL);
      g_signal_connect (quit_action, "activate", G_CALLBACK (quit_callback), app);
      /* Přidá ji pro celou aplikaci */
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
    
      /* Začne vytvářet akci "state"
       * Všimněte si, že tato akce je stavová
       */
      GVariantType *type_string2 = g_variant_type_new ("s");
      state_action = g_simple_action_new_stateful ("state", type_string2,
                                                   g_variant_new_string ("off"));
      g_signal_connect (state_action, "activate", G_CALLBACK (state_callback), app);
      /* Přidá ji pro celou aplikaci */
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (state_action));
      g_variant_type_free (type_string2);
    
      /* Začne vytvářet akci "awesome"
       * Všimněte si, že tato akce je stavová
       */
      awesome_action = g_simple_action_new_stateful ("awesome", NULL, g_variant_new_boolean (FALSE));
      g_signal_connect (awesome_action, "activate", G_CALLBACK (awesome_callback), app);
      /* Přidá ji pro celou aplikaci */
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (awesome_action));
    
      /* Použije builder pro přidání návrhu uživatelského rozhraní z GLADE do mřížky */
      builder = gtk_builder_new ();
      /* Získá soubor (pokud existuje)
       * Poznámka: musíte se ujistit, že soubor je v aktuální složce s touto
       * prací. Pokud je objevena chyba, funkce použitá zde vrací neprázdnou
       * hodnotu do naší proměnné "error"
       */
      gtk_builder_add_from_file (builder, "menubar.ui", &amp;error);
      if (error != NULL) {
         g_print ("%s\n", error-&gt;message);
         g_error_free (error);
      }
    
      /* Získá nabídkovou lištu */
      GObject *menubar = gtk_builder_get_object (builder, "menubar");
      gtk_application_set_menubar (GTK_APPLICATION (app), G_MENU_MODEL (menubar));
    
      /* Získá aplikační nabídku */
      GObject *appmenu = gtk_builder_get_object (builder, "appmenu");
      gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (appmenu));
    }
    
    
    
    /* Spouštěcí funkce pro aplikaci */
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: page/title
en: MenuBar created using XML and GtkBuilder
cs: MenuBar vytvořený pomocí XML a GtkBuilder

note: (itstool) path: section/title
en: Create a MenuBar using XML
cs: Vytvoření MenuBar pomocí XML

note: (itstool) path: section/p
en: To create the menubar using XML:
cs: Abyste vytvořili nabídkovou lištu pomocí XML:

note: (itstool) path: item/p
en: Create <file>menubar.ui</file> using your favorite text editor.
cs: Pomocí svého oblíbeného textového editoru vytvořte <file>menubar.ui</file>.

note: (itstool) path: item/p
en: Enter the following line at the top of the file:
cs: Na začátek souboru vložte následující řádek:

note: (itstool) path: item/p
en: We want to create the interface which will contain our menubar and its submenus. Our menubar will contain <gui>File</gui>, <gui>Edit</gui>, <gui>Choices</gui> and <gui>Help</gui> submenus. We add the following XML code to the file:
cs: Chceme vytvořit rozhraní, které bude obsahovat naši nabídkovou lištu a její podnabídky. Naše nabídková lišta bude obsahovat podnabídky <gui>Soubor</gui>, <gui>Upravit</gui>, <gui>Volby</gui> a <gui>Nápověda</gui>. Do souboru přidáme následující kód XML:

note: (itstool) path: item/p
en: Now we will create the .py file and use GtkBuilder to import the <file>menubar.ui</file> we just created.
cs: Nyní vytvoříme soubor .py a použijeme GtkBuilder k naimportování souboru <file>menubar.ui</file>, který jsme před chvílí vytvořili.

note: (itstool) path: section/title
en: Add the MenuBar to the window using GtkBuilder
cs: Přidání MenuBar do okna pomocí GtkBuilder

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="MenuBar Example", application=app)
            self.set_default_size(200, 200)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # a builder to add the UI designed with Glade to the grid:
            builder = Gtk.Builder()
            # get the file (if it is there)
            try:
                builder.add_from_file("menubar_basis.ui")
            except:
                print("file not found")
                sys.exit()
    
            # we use the method Gtk.Application.set_menubar(menubar) to add the menubar
            # to the application (Note: NOT the window!)
            self.set_menubar(builder.get_object("menubar"))
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="MenuBar Example", application=app)
            self.set_default_size(200, 200)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # Builder pro přidání uživatelského rozhraní navrženého v Glade do mřížky
            builder = Gtk.Builder()
            # Získá soubor (pokud existuje)
            try:
                builder.add_from_file("menubar_basis.ui")
            except:
                print("file not found")
                sys.exit()
    
            # Použije metodu Gtk.Application.set_menubar(nabídková_lišta) pro přídání
            # nabídkové lišty do aplikace (Upozornění: NE do okna!)
            self.set_menubar(builder.get_object("menubar"))
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/p
en: Now run the python application. It should look like the picture at the top of this page.
cs: Nyní aplikaci napsanou v jazyce Python spusťte. Měla by vypadat podobně, jako na obrázku na začátku této stránky.

note: (itstool) path: section/title
en: Add items to the menus
cs: Přidání položek do nabídky

note: (itstool) path: section/p
en: We start off by adding 2 menuitems to the <gui>File</gui> menu: <gui>New</gui> and <gui>Quit</gui>. We do this by adding a <code>section</code> to the the <code>File</code> submenu with these items. The <file>menubar.ui</file> should look like this (lines 6 to 13 inclusive comprise the newly added section):
cs: Začneme přidáním dvou položek nabídky do nabídky <gui>File</gui>: <gui>New</gui> a <gui>Quit</gui>. Provedeme to přidáním <code>oddílu</code> s těmito položkami do podnabídky <code>File</code>. Soubor <file>menubar.ui</file> by měl vypadat jako tento (řádky 6 až 13 včetně obsahují nově přidaný oddíl):

note: (itstool) path: section/p
en: Following this pattern, you can now add a <code>Copy</code> and a <code>Paste</code> item to the <code>Edit</code> submenu, and an <code>About</code> item to the <code>Help</code> submenu.
cs: Podle tohoto vzoru nyní můžete přidat položky <gui>Copy</gui> a <gui>Paste</gui> do podnabídky <gui>Edit</gui> a položku <gui>About</gui> do podnabídky <gui>Help</gui>.

note: (itstool) path: section/title
en: Setup actions
cs: Nastavení akcí

note: (itstool) path: section/p
en: We now create the actions for "New" and "Quit" connected to a callback function in the Python file; for instance we create "new" as:
cs: Nyní vytvoříme akce pro „New“ a „Quit“ napojené na funkce zpětného volání v souboru .py. Například „new“ vytvoříme jako:

note: (itstool) path: section/p
en: And we create the callback function of "new" as
cs: A vytvoříme funkci zpětného volání pro „new“ jako

note: (itstool) path: section/p
en: Now, in the XML file, we connect the menu items to the actions in the XML file by adding the "action" attribute:
cs: Nyní v souboru XML napojíme položky nabídky na akce v souboru XML přidáním atributu „action“:

note: (itstool) path: section/p
en: Note that for an action that is relative to the application, we use the prefix <code>app.</code>; for actions that are relative to the window we use the prefix <code>win.</code>.
cs: Všimněte si, že pro akce, které se vztahují k aplikaci, používáme předponu <code>app.</code> a pro akce, které se vztahují k oknu, používáme předponu <code>win.</code>.

note: (itstool) path: section/p
en: Finally, in the Python file, we add the action to the application or to the window - so for instance <code>app.new</code> will be added to the application in the method <code>do_startup(self)</code> as
cs: Nakonec v souboru <file>.py</file> přidáme akci do aplikace nebo do okna – například <code>app.new</code> bude přidáno do aplikace v metodě <code>do_startup(self)</code> jako

note: (itstool) path: section/p
en: See <link xref="signals-callbacks.py"/> for a more detailed explanation of signals and callbacks.
cs: Podrobnější vysvětlení signálů a zpětných volání viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: section/title
en: Actions: Application or Window?
cs: Akce: Aplikace nebo okno?

note: (itstool) path: section/p
en: Above, we created the "new" and "open" actions as part of the MyApplication class. Actions which control the application itself, such as "quit" should be created similarly.
cs: Výše jsme vytvořili akce <code>"new"</code> a <code>"open"</code> jako součást třídy <code>MyApplication</code>. Akce, které ovládají přímo aplikaci, jako je <code>"quit"</code> by se vytvořily podobně.

note: (itstool) path: section/p
en: Some actions, such as "copy" and "paste" deal with the window, not the application. Window actions should be created as part of the window class.
cs: Některé akce, jako je <code>"copy"</code> (kopírovat) nebo <code>"paste"</code> (vložit) se vztahují k oknu a ne k aplikaci. Akce okna by měly být vytvářeny jako součást třídy okna.

note: (itstool) path: section/p
en: The complete example files contain both application actions and window actions. The window actions are the ones usually included in the <link xref="gmenu.py">application menu</link> also. It is not good practice to include window actions in the application menu. For demonstration purposes, the complete example files which follow include XML in the UI file which creates the application menu which includes a "New" and "Open" item, and these are hooked up to the same actions as the menubar items of the same name.
cs: Soubor s celým příkladem obsahuje jak akce aplikace, tak akce okna. Akce okna jsou obvykle zároveň i součástí <link xref="gmenu.py">aplikační nabídky</link>. Není dobrým zvykem vkládat akce okna do aplikační nabídky. Pro předváděcí účely zahrnuje soubor s celým příkladem, který následuje, kód XML v souboru <file>.ui</file>, který vytvoří aplikační nabídku včetně položek <code>"New"</code> a <code>"Open"</code> a ty jsou zavěšeny na stejnou akci, jako položky nabídkové lišty se stejným názvem.

note: (itstool) path: section/title
en: Choices submenu and items with state
cs: Podnabídka „Choices“ a položky se stavem

note: (itstool) path: section/p
en: Lines 30 to 80 inclusive of the <link xref="menubar.py#xml-code"/> demonstrate the XML code used to create the UI for <gui>Choices</gui> menu.
cs: Řádky 30 až 80 včetně v <link xref="menubar.py#xml-code"/> ukazují kód XML použitý k vytvoření uživatelského rozhraní pro nabídku <gui>Choices</gui>.

note: (itstool) path: section/p
en: The actions created so far are <em>stateless</em>, that is they do not retain or depend on a state given by the action itself. The actions we need to create for the Choices submenu, on the other hand, are <em>stateful</em>. An example of creation of a stateful action is:
cs: Dosud vytvořené akce jsou <em>bezstavové</em>, tj. takové, které si nepamatují stave nebo nezávisí na stavu akce samotné. Akce, které potřebujeme vytvořit pro podnabídku <gui>Choices</gui> jsou na druhou stranu <em>stavové</em>. Příkladem vytvoření stavové akce je:

note: (itstool) path: section/p
en: where the variables of the method are: name, parameter type (in this case, a string - see <link href="http://developer.gnome.org/glib/unstable/glib-GVariantType.html">here</link> for a complete list of character meanings), initial state (in this case, 'line' - in case of a <code>True</code> boolean value it should be <code>Glib.Variant.new_boolean(True)</code>, and so on, see <link href="http://developer.gnome.org/glib/unstable/glib-GVariant.html">here</link> for a complete list)
cs: kde proměnné v metodě jsou: název, typ parametru (v tomto případě řetězec, úplný seznam s významem znaků viz <link href="http://developer.gnome.org/glib/unstable/glib-GVariantType.html">zde</link>), počáteční stav (v tomto případě <code>'line'</code>, v případě pravdivostní hodnoty <code>True</code> by to mělo být <code>Glib.Variant.new_boolean(True)</code> apod.; úplný seznam viz <link href="http://developer.gnome.org/glib/unstable/glib-GVariant.html">zde</link>).

note: (itstool) path: section/p
en: After creating the stateful SimpleAction we connect it to the callback function and we add it to the window (or the application, if it is the case), as before:
cs: Po vytvoření stavové jednoduché akce ji napojíme na funkci zpětného volání a přidáme ji do okna (nebo do aplikace v některých případech), stejně jako dřív:

note: (itstool) path: section/title
en: Complete XML UI file for this example
cs: Celý soubor s uživatelským rozhraním ve formátu XML pro tento příklad

note: (itstool) path: section/title
en: Complete Python file for this example
cs: Kompletní soubor v jazyce Python pro tento příklad

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import GLib
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="MenuBar Example", application=app)
            self.set_default_size(200, 200)
    
            # action without a state created (name, parameter type)
            copy_action = Gio.SimpleAction.new("copy", None)
            # connected with the callback function
            copy_action.connect("activate", self.copy_callback)
            # added to the window
            self.add_action(copy_action)
    
            # action without a state created (name, parameter type)
            paste_action = Gio.SimpleAction.new("paste", None)
            # connected with the callback function
            paste_action.connect("activate", self.paste_callback)
            # added to the window
            self.add_action(paste_action)
    
            # action with a state created (name, parameter type, initial state)
            shape_action = Gio.SimpleAction.new_stateful(
                "shape", GLib.VariantType.new('s'), GLib.Variant.new_string('line'))
            # connected to the callback function
            shape_action.connect("activate", self.shape_callback)
            # added to the window
            self.add_action(shape_action)
    
            # action with a state created
            about_action = Gio.SimpleAction.new("about", None)
            # action connected to the callback function
            about_action.connect("activate", self.about_callback)
            # action added to the application
            self.add_action(about_action)
    
        # callback function for copy_action
        def copy_callback(self, action, parameter):
            print("\"Copy\" activated")
    
        # callback function for paste_action
        def paste_callback(self, action, parameter):
            print("\"Paste\" activated")
    
        # callback function for shape_action
        def shape_callback(self, action, parameter):
            print("Shape is set to", parameter.get_string())
            # Note that we set the state of the action!
            action.set_state(parameter)
    
        # callback function for about (see the AboutDialog example)
        def about_callback(self, action, parameter):
            # a  Gtk.AboutDialog
            aboutdialog = Gtk.AboutDialog()
    
            # lists of authors and documenters (will be used later)
            authors = ["GNOME Documentation Team"]
            documenters = ["GNOME Documentation Team"]
    
            # we fill in the aboutdialog
            aboutdialog.set_program_name("MenuBar Example")
            aboutdialog.set_copyright(
                "Copyright \xc2\xa9 2012 GNOME Documentation Team")
            aboutdialog.set_authors(authors)
            aboutdialog.set_documenters(documenters)
            aboutdialog.set_website("http://developer.gnome.org")
            aboutdialog.set_website_label("GNOME Developer Website")
    
            # to close the aboutdialog when "close" is clicked we connect the
            # "response" signal to on_close
            aboutdialog.connect("response", self.on_close)
            # show the aboutdialog
            aboutdialog.show()
    
        # a callback function to destroy the aboutdialog
        def on_close(self, action, parameter):
            action.destroy()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            # FIRST THING TO DO: do_startup()
            Gtk.Application.do_startup(self)
    
            # action without a state created
            new_action = Gio.SimpleAction.new("new", None)
            # action connected to the callback function
            new_action.connect("activate", self.new_callback)
            # action added to the application
            self.add_action(new_action)
    
            # action without a state created
            quit_action = Gio.SimpleAction.new("quit", None)
            # action connected to the callback function
            quit_action.connect("activate", self.quit_callback)
            # action added to the application
            self.add_action(quit_action)
    
            # action with a state created
            state_action = Gio.SimpleAction.new_stateful(
                "state",  GLib.VariantType.new('s'), GLib.Variant.new_string('off'))
            # action connected to the callback function
            state_action.connect("activate", self.state_callback)
            # action added to the application
            self.add_action(state_action)
    
            # action with a state created
            awesome_action = Gio.SimpleAction.new_stateful(
                "awesome", None, GLib.Variant.new_boolean(False))
            # action connected to the callback function
            awesome_action.connect("activate", self.awesome_callback)
            # action added to the application
            self.add_action(awesome_action)
    
            # a builder to add the UI designed with Glade to the grid:
            builder = Gtk.Builder()
            # get the file (if it is there)
            try:
                builder.add_from_file("menubar.ui")
            except:
                print("file not found")
                sys.exit()
    
            # we use the method Gtk.Application.set_menubar(menubar) to add the menubar
            # and the menu to the application (Note: NOT the window!)
            self.set_menubar(builder.get_object("menubar"))
            self.set_app_menu(builder.get_object("appmenu"))
    
        # callback function for new
        def new_callback(self, action, parameter):
            print("You clicked \"New\"")
    
        # callback function for quit
        def quit_callback(self, action, parameter):
            print("You clicked \"Quit\"")
            sys.exit()
    
        # callback function for state
        def state_callback(self, action, parameter):
            print("State is set to", parameter.get_string())
            action.set_state(parameter)
    
        # callback function for awesome
        def awesome_callback(self, action, parameter):
            action.set_state(GLib.Variant.new_boolean(not action.get_state()))
            if action.get_state().get_boolean() is True:
                print("You checked \"Awesome\"")
            else:
                print("You unchecked \"Awesome\"")
    
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import GLib
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="MenuBar Example", application=app)
            self.set_default_size(200, 200)
    
            # Vytvoří bezstavovou akci (název, typ parametru)
            copy_action = Gio.SimpleAction.new("copy", None)
            # Napojí ji na funkci zpětného volání
            copy_action.connect("activate", self.copy_callback)
            # Přidá ji do okna
            self.add_action(copy_action)
    
            # Vytvoří bezstavovou akci (název, typ parametru)
            paste_action = Gio.SimpleAction.new("paste", None)
            # Napojí ji na funkci zpětného volání
            paste_action.connect("activate", self.paste_callback)
            # Přidá ji do okna
            self.add_action(paste_action)
    
            # Vytvoří stavovou akci (název, typ_parametru, počáteční_stav)
            shape_action = Gio.SimpleAction.new_stateful(
                "shape", GLib.VariantType.new('s'), GLib.Variant.new_string('line'))
            # Napojí ji na funkci zpětného volání
            shape_action.connect("activate", self.shape_callback)
            # Přidá ji do okna
            self.add_action(shape_action)
    
            # Vytvoří stavovou akci
            about_action = Gio.SimpleAction.new("about", None)
            # Napojí ji na funkci zpětného volání
            about_action.connect("activate", self.about_callback)
            # Přidá ji do aplikace
            self.add_action(about_action)
    
        # Funkce zpětného volání pro copy_action
        def copy_callback(self, action, parameter):
            print("\"Copy\" activated")
    
        # Funkce zpětného volání pro paste_action
        def paste_callback(self, action, parameter):
            print("\"Paste\" activated")
    
        # Funkce zpětného volání pro shape_action
        def shape_callback(self, action, parameter):
            print("Shape is set to", parameter.get_string())
            # Note that we set the state of the action!
            action.set_state(parameter)
    
        # Funkce zpětného volání pro about (viz příklad AboutDialog)
        def about_callback(self, action, parameter):
            # Gtk.AboutDialog
            aboutdialog = Gtk.AboutDialog()
    
            # Seznam autorů kódu a dokumentace (bude použit později)
            authors = ["GNOME Documentation Team"]
            documenters = ["GNOME Documentation Team"]
    
            # Vyplní AboutDialog
            aboutdialog.set_program_name("MenuBar Example")
            aboutdialog.set_copyright(
                "Copyright \xc2\xa9 2012 GNOME Documentation Team")
            aboutdialog.set_authors(authors)
            aboutdialog.set_documenters(documenters)
            aboutdialog.set_website("http://developer.gnome.org")
            aboutdialog.set_website_label("GNOME Developer Website")
    
            # Napojí signál "response" na on_close, aby se zavřel 
            # AboutDialog, když je kliknuto na "close"
            aboutdialog.connect("response", self.on_close)
            # Zobrazí AboutDialog
            aboutdialog.show()
    
        # Funkce zpětného volání pro likvidaci AboutDialog
        def on_close(self, action, parameter):
            action.destroy()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            # PRVNÍ, CO SE MUSÍ UDĚLAT: do_startup()
            Gtk.Application.do_startup(self)
    
            # Vytvoří bezstavovou akci
            new_action = Gio.SimpleAction.new("new", None)
            # Napojí ji na funkci zpětného volání
            new_action.connect("activate", self.new_callback)
            # Přidá ji do aplikace
            self.add_action(new_action)
    
            # Vytvoří bezstavovou akci
            quit_action = Gio.SimpleAction.new("quit", None)
            # Napojí ji na funkci zpětného volání
            quit_action.connect("activate", self.quit_callback)
            # Přidá ji do aplikace
            self.add_action(quit_action)
    
            # Vytvoří stavovou akci
            state_action = Gio.SimpleAction.new_stateful(
                "state",  GLib.VariantType.new('s'), GLib.Variant.new_string('off'))
            # Napojí ji na funkci zpětného volání
            state_action.connect("activate", self.state_callback)
            # Přidá ji do aplikace
            self.add_action(state_action)
    
            # Vytvoří stavovou akci
            awesome_action = Gio.SimpleAction.new_stateful(
                "awesome", None, GLib.Variant.new_boolean(False))
            # Napojí ji na funkci zpětného volání
            awesome_action.connect("activate", self.awesome_callback)
            # Přidá ji do aplikace
            self.add_action(awesome_action)
    
            # Builder, který přidá navrh uživatelského rozhraní z Glade do mřížky
            builder = Gtk.Builder()
            # Získá soubor (pokud existuje)
            try:
                builder.add_from_file("menubar.ui")
            except:
                print("file not found")
                sys.exit()
    
            # Použije metodu Gtk.Application.set_menubar(menubar) pro přidání
            # nabídkové lišty a aplikační nabídky (Poznámka: NE do okna!)
            self.set_menubar(builder.get_object("menubar"))
            self.set_app_menu(builder.get_object("appmenu"))
    
        # Funkce zpětného volání pro new
        def new_callback(self, action, parameter):
            print("You clicked \"New\"")
    
        # Funkce zpětného volání pro quit
        def quit_callback(self, action, parameter):
            print("You clicked \"Quit\"")
            sys.exit()
    
        # Funkce zpětného volání pro state
        def state_callback(self, action, parameter):
            print("State is set to", parameter.get_string())
            action.set_state(parameter)
    
        # Funkce zpětného volání pro awesome
        def awesome_callback(self, action, parameter):
            action.set_state(GLib.Variant.new_boolean(not action.get_state()))
            if action.get_state().get_boolean() is True:
                print("You checked \"Awesome\"")
            else:
                print("You unchecked \"Awesome\"")
    
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Mnemonics and Accelerators
cs: Horké klávesy a klávesové zkratky

note: (itstool) path: section/p
en: Labels may contain mnemonics. Mnemonics are underlined characters in the label, used for keyboard navigation. Mnemonics are created by placing an underscore before the mnemonic character. For example "_File" instead of just "File" in the menubar.ui label attribute.
cs: Popisky mohou obsahovat horké (mnemotechnické) klávesy. Mají podobu podtržených písmen v popiscích a používají se pro ovládání z klávesnice. Horké klávesy se vytváří umístěním podtržítka před příslušný znak. Například <code>"_File"</code> namísto <code>"File"</code> v atributu <code>label</code> v <file>menubar.ui</file>.

note: (itstool) path: section/p
en: The mnemonics are visible when you press the <key>Alt</key> key. Pressing <keyseq><key>Alt</key><key>F</key></keyseq> will open the <gui>File</gui> menu.
cs: Horké klávesy jsou vidět, když zmáčknete klávesu <key>Alt</key>. Zmáčknutím <keyseq><key>Alt</key> <key>F</key></keyseq> otevřete nabídku <gui>File</gui>.

note: (itstool) path: section/p
en: Accelerators can be explicitly added in the UI definitions. For example, it is common to be able to quit an application by pressing <keyseq><key>Ctrl</key><key>Q</key></keyseq> or to save a file by pressing <keyseq><key>Ctrl</key><key>S</key></keyseq>. To add an accelerator to the UI definition, you simply need add an "accel" attribute to the item.
cs: Klávesové zkratky mohou být přidány přímo do definicí uživatelského rozhraní. Například je běžné, že aplikaci lze ukončit zmáčknutím <keyseq><key>Ctrl</key><key>Q</key></keyseq>, nebo že lze uložit soubor zmáčknutím <keyseq><key>Ctrl</key><key>S</key></keyseq>. Pro přidání klávesové zkratky do definice uživatelského rozhraní stačí akorát přidat do položky atribut <code>"accel"</code>.

note: (itstool) path: section/p
en: <code mime="application/xml">&lt;attribute name="accel"&gt;&amp;lt;Primary&amp;gt;q&lt;/attribute&gt;</code> will create the <keyseq><key>Ctrl</key><key>Q</key></keyseq> sequence when added to the <code>Quit</code> label item. Here, "Primary" refers to the <key>Ctrl</key> key on a PC or the <key>⌘</key> key on a Mac.
cs: <code mime="application/xml">&lt;attribute name="accel"&gt;&amp;lt;Primary&amp;gt;q&lt;/attribute&gt;</code> vytvoří sekvenci <keyseq><key>Ctrl</key><key>Q</key></keyseq> při přidávání položky <code>Quit</code>. „Primary“ má zde význam klávesy <key>Ctrl</key> na počítačích PC nebo klávesy <key>⌘</key> na počítačích Mac.

note: (itstool) path: section/title
en: Translatable strings
cs: Přeložitelné řetězce

note: (itstool) path: section/p
en: Since GNOME applications are being translated into <link href="http://l10n.gnome.org/languages/">many languages</link>, it is important that the strings in your application are translatable. To make a label translatable, simple set <code>translatable="yes"</code>:
cs: Protože aplikace GNOME jsou překládány do <link href="http://l10n.gnome.org/languages/">mnoha jazyků</link>, je důležité, aby řetězce ve vaší aplikaci byly přeložitelné. U popisku to zajistíte jednoduše nastavením <code>translatable="yes"</code>:

note: (itstool) path: item/p
en: Now we will create the .vala file and use GtkBuilder to import the <file>menubar.ui</file> we just created.
cs: Nyní vytvoříme soubor .vala a použijeme GtkBuilder k importu souboru <file>menubar.ui</file>, který jsem před chvílí vytvořili.

note: (itstool) path: section/code
en: public class MyWindow : Gtk.ApplicationWindow {
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "MenuBar Example");
    		this.set_default_size (200, 200);
    	}
    }
    
    class MyApplication: Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    	protected override void startup () {
    		base.startup ();
    
    		/* Setup menubar. */
    		/* Get the UI file. */
    		var builder = new Gtk.Builder ();
    		try {
    			builder.add_from_file ("menubar_basis.ui");
    		/* Handle the exception. */
    		} catch (Error e) {
    			error ("Unable to load file: %s", e.message);
    		}
    
    		/* Get the menubar from the builder. */
    		this.menubar = builder.get_object ("menubar") as MenuModel;
    	}
    }
    
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: public class MyWindow : Gtk.ApplicationWindow {
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "MenuBar Example");
    		this.set_default_size (200, 200);
    	}
    }
    
    class MyApplication: Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    	protected override void startup () {
    		base.startup ();
    
    		/* Nastaví nabídkovou lištu. */
    		/* Získá soubor UI. */
    		var builder = new Gtk.Builder ();
    		try {
    			builder.add_from_file ("menubar_basis.ui");
    		/* Obsloužení výjimky. */
    		} catch (Error e) {
    			error ("Unable to load file: %s", e.message);
    		}
    
    		/* Získá nabídkovou lištu z objektu builder. */
    		this.menubar = builder.get_object ("menubar") as MenuModel;
    	}
    }
    
    /* main vytvoří a spustí aplikaci. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: section/p
en: Now, compile the vala file, and run it. The application should look like the picture at the top of this page.
cs: Nyní soubor .vala zkompilujte a spusťte. Aplikace by měla vypadat podobně, jako na obrázku na začátku této stránky.

note: (itstool) path: section/p
en: Following this pattern, you can now add a <code>Copy</code> and a <code>Paste</code> item to the <code>Edit</code> submenu, and an <code>About</code> item to the <code>Help</code> submenu. We will hold off on adding items to the <link xref="menubar.vala#choices">Choices submenu</link> until further in the tutorial.
cs: Podle tohoto vzoru nyní můžete přidat položky <gui>Copy</gui> a <gui>Paste</gui> do podnabídky <gui>Edit</gui> a položku <gui>About</gui> do podnabídky <gui>Help</gui>. Zatím se vyhneme přidání položek do <link xref="menubar.vala#choices">podnabídky <gui>Choices</gui></link>, tomu se budeme věnovat později v této lekci.

note: (itstool) path: note/p
en: You do not need to recompile the vala program if you only made changes to the UI file. Just run your previously compiled application, and the UI changes will be reflected.
cs: Když provedete změny v souboru s uživatelským rozhraním, nemusíte znovu kompilovat program. Stačí již dříve zkompilovaná aplikace a změny v uživatelském rozhraní se projeví.

note: (itstool) path: section/p
en: This is a three step process.
cs: Jde o postup se třemi kroky.

note: (itstool) path: item/p
en: First we create the ActionEntry array in the MyApplication class. An ActionEntry consists of:
cs: Nejprve vytvoříme pole <code>ActionEntry</code> ve třídě <code>MyApplication</code>. To se bude skládat z:

note: (itstool) path: item/p
en: the "action name" (mandatory)
cs: názvu akce <code>"action name"</code> (povinné)

note: (itstool) path: item/p
en: the callback function to connect to the "activate" signal of the action (if applicable)
cs: funkce zpětného volání napojené na signál <code>"activate"</code> akce (pokud to je použitelné)

note: (itstool) path: item/p
en: the type of the parameter that must be passed to the activate function for the action (if applicable)
cs: typu parametru, který musí být předán aktivační funkci pro akci (pokud je to použitelné)

note: (itstool) path: item/p
en: the initial state for this action (if applicable)
cs: počáteční stav této akce (pokud je to použitelné)

note: (itstool) path: item/p
en: the callback to connect to "change-state" signal (if applicable)
cs: zpětné volání napojené na signál <code>"change-state"</code> (pokud je to použitelné)

note: (itstool) path: item/p
en: Second, we create the callback functions the actions are connected to.
cs: Zadruhé vytvoříme funkce zpětného volání, na které jsou akce napojené.

note: (itstool) path: item/p
en: And lastly, we connect the menu items to the actions in the XML file by adding the "action" attribute:
cs: A nakonec v souboru XML napojíme položku nabídky na akci přidáním atributu <code>"action"</code>:

note: (itstool) path: section/p
en: Lines 30 to 80 inclusive of the <link xref="menubar.vala#xml-code"/> demonstrate the XML code used to create the UI for <gui>Choices</gui> menu.
cs: Řádky 30 až 80 včetně v <link xref="menubar.vala#xml-code"/> předvádí kód XML použitý k vytvoření uživatelského rozhraní nabídky <gui>Choices</gui>.

note: (itstool) path: section/p
en: The complete example files contain both application actions and window applications. The window actions are the ones usually included in the <link xref="gmenu.vala">application menu</link> also. It is not good practice to include window actions in the application menu. For demonstration purposes, the complete example files which follow include XML in the UI file which creates the application menu which includes a "New" and "Open" item, and these are hooked up to the same actions as the menubar items of the same name.
cs: Soubor s celým příkladem obsahuje jak akce aplikace, tak akce okna. Akce okna jsu obvykle zároveň i součástí <link xref="gmenu.vala">aplikační nabídky</link>. Není dobrým zvykem vkládat akce okna do aplikační nabídky. Pro předváděcí účely zahrnuje soubor s celým příkladem, který následuje, kód XML v souboru <file>.ui</file>, který vytvoří aplikační nabídku včetně položek <code>"New"</code> a <code>"Open"</code> a ty jsou zavěšeny na stejnou akci, jako položky nabídkové lišty se stejným názvem.

note: (itstool) path: section/title
en: Complete Vala file for this example
cs: Kompletní soubor v jazyce Vala pro tento příklad

note: (itstool) path: section/code
en: public class MyWindow : Gtk.ApplicationWindow {
    
    	/* Callback functions for the window actions. */
    	void copy_cb (SimpleAction action, Variant? parameter) {
    		print ("\"Copy\" activated\n");
    	}
    
    	void paste_cb (SimpleAction action, Variant? parameter) {
    		print ("\"Paste\" activated\n");
    	}
    
    	void shape_cb (SimpleAction action, Variant? parameter) {
    		print ("shape is set to %s\n", parameter.get_string(null));
    		action.set_state (parameter);
    	}
    
    	/* Create the window actions. */
    	const ActionEntry[] actions = {
    		/*{ "action name", cb to connect to "activate" signal, parameter type,
    		     initial state, cb to connect to "change-state" signal } */
    		{ "copy", copy_cb },
    		{ "paste", paste_cb },
    		{ "shape", shape_cb, "s", "'line'"}
    	};
    
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "MenuBar Example");
    		this.set_default_size (200, 200);
    
    		/* Setup window actions. */
    		this.add_action_entries (actions, this);
    	}
    }
    
    class MyApplication: Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    	/* Callback functions for the application actions. */
    	void new_cb (SimpleAction action, Variant? parameter) {
    		//new MyWindow (this).show ();
    		print ("You clicked \"New\"\n");
    	}
    
    	void quit_cb (SimpleAction action, Variant? parameter) {
    		print ("You clicked \"Quit\"\n");
    		this.quit ();
    	}
    
    	void awesome_cb (SimpleAction action, Variant? parameter) {
    		var active = action.get_state ().get_boolean ();
    		action.set_state (new Variant.boolean (!active));
    		if (active)
    			print ("You unchecked \"Awesome\"\n");
    		else
    			print ("You checked \"Awesome\"\n");
    	}
    
    	void state_cb (SimpleAction action, Variant? parameter) {
    		print ("state is set to %s\n", parameter.get_string(null));
    		action.set_state (parameter);
    	}
    
    	/* Create the application actions. */
    	const ActionEntry[] actions = {
    		{ "new", new_cb },
    		{ "quit", quit_cb },
    		{ "awesome", awesome_cb, null, "false" },
    		{ "state", state_cb, "s", "'off'" }
    	};
    
    	protected override void startup () {
    		base.startup ();
    
    		/* Setup application actions. */
    		this.add_action_entries (actions, this);
    
    		/* Setup menubar and app_menu. */
    		/* Get the UI file. */
    		var builder = new Gtk.Builder ();
    		try {
    			builder.add_from_file ("menubar.ui");
    		} catch (Error e) {
    			error ("Unable to load file: %s", e.message);
    		}
    
    		/* Get the menubar from the builder. */
    		this.menubar = builder.get_object ("menubar") as MenuModel;
    
    		/* Get the app_menu from the builder. */
    		this.app_menu = builder.get_object ("appmenu") as MenuModel;
    	}
    }
    
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: public class MyWindow : Gtk.ApplicationWindow {
    
    	/* Funkce zpětného volání pro akce okna */
    	void copy_cb (SimpleAction action, Variant? parameter) {
    		print ("\"Copy\" activated\n");
    	}
    
    	void paste_cb (SimpleAction action, Variant? parameter) {
    		print ("\"Paste\" activated\n");
    	}
    
    	void shape_cb (SimpleAction action, Variant? parameter) {
    		print ("shape is set to %s\n", parameter.get_string(null));
    		action.set_state (parameter);
    	}
    
    	/* Vytvoří akce okna */
    	const ActionEntry[] actions = {
    		/*{ "název akce", zpětné volání pro přípojení signálu "activate", 
    		    typ parametru, počáteční stav, zpětné volání pro připojení 
    		    signálu "change-state" } */
    		{ "copy", copy_cb },
    		{ "paste", paste_cb },
    		{ "shape", shape_cb, "s", "'line'"}
    	};
    
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "MenuBar Example");
    		this.set_default_size (200, 200);
    
    		/* Nastaví akce oknu */
    		this.add_action_entries (actions, this);
    	}
    }
    
    class MyApplication: Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    	/* Funkce zpětného volání pro akce aplikace */
    	void new_cb (SimpleAction action, Variant? parameter) {
    		//new MyWindow (this).show ();
    		print ("You clicked \"New\"\n");
    	}
    
    	void quit_cb (SimpleAction action, Variant? parameter) {
    		print ("You clicked \"Quit\"\n");
    		this.quit ();
    	}
    
    	void awesome_cb (SimpleAction action, Variant? parameter) {
    		var active = action.get_state ().get_boolean ();
    		action.set_state (new Variant.boolean (!active));
    		if (active)
    			print ("You unchecked \"Awesome\"\n");
    		else
    			print ("You checked \"Awesome\"\n");
    	}
    
    	void state_cb (SimpleAction action, Variant? parameter) {
    		print ("state is set to %s\n", parameter.get_string(null));
    		action.set_state (parameter);
    	}
    
    	/* Vytvoří akce aplikace */
    	const ActionEntry[] actions = {
    		{ "new", new_cb },
    		{ "quit", quit_cb },
    		{ "awesome", awesome_cb, null, "false" },
    		{ "state", state_cb, "s", "'off'" }
    	};
    
    	protected override void startup () {
    		base.startup ();
    
    		/* Nastaví akce aplikaci */
    		this.add_action_entries (actions, this);
    
    		/* Nastaví nabídkovou lištu a aplikační nabídku */
    		/* Získá soubor s uživatelským rozhraním */
    		var builder = new Gtk.Builder ();
    		try {
    			builder.add_from_file ("menubar.ui");
    		} catch (Error e) {
    			error ("Unable to load file: %s", e.message);
    		}
    
    		/* Získá nabídkovou lištu od objektu builder */
    		this.menubar = builder.get_object ("menubar") as MenuModel;
    
    		/* Získá aplikační nabídku od objektu builder */
    		this.app_menu = builder.get_object ("appmenu") as MenuModel;
    	}
    }
    
    /* main vytvoří a spustí aplikaci */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: section/title
en: Mnemonics
cs: Horké klávesy

note: (itstool) path: section/title
en: Accelerators
cs: Klávesové zkratky

note: (itstool) path: info/desc
en: A widget that shows a menu when clicked on
cs: Tlačítko, které po kliknutí zobrazí nabídku

note: (itstool) path: page/p
en: The GtkMenuButton widget is used to display a menu when clicked on. This menu can be provided either as a GtkMenu, or an abstract GMenuModel. The GtkMenuButton widget can hold any valid child widget. That is, it can hold almost any other standard GtkWidget. The most commonly used child is the provided GtkArrow.
cs: Widget <code>GtkMenuButton</code> se používá k zobrazení nabídky po kliknutí na něj. Nabídka může být poskytnuta v podobě <code>GtkMenu</code> nebo jako abstraktní <code>GMenuModel</code>. Tlačítko může obsahovat libovolný platný synovský widget. To znamená, že může obsahovat většinu ostatních standardních potomků <code>GtkWidget</code>. Nejčastěji používaným vloženým widgetem je <code>GtkArrow</code>.

note: (itstool) path: note/p
en: You need to be running GNOME 3.6 or later for the MenuButton to work.
cs: Musíte používat GNOME 3.6 nebo novější, aby widget MenuButton fungoval.

note: (itstool) path: section/code
en: #include &lt;gtk/gtk.h&gt;
    
    /* Callback function for the undo action */
    static void
    about_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      g_print ("You clicked \"About\"\n");
    }
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GMenu *submenu;
      GtkWidget *grid;
      GMenu *menumodel;
      GtkWidget *window;
      GtkWidget *menubutton;
      GSimpleAction *about_action;
    
      window = gtk_application_window_new (app);
      grid = gtk_grid_new ();
    
      gtk_window_set_title (GTK_WINDOW (window), "MenuButton Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
    
      menubutton = gtk_menu_button_new ();
      gtk_widget_set_size_request (menubutton, 80, 35);
    
      gtk_grid_attach (GTK_GRID (grid), menubutton, 0, 0, 1, 1);
      gtk_container_add (GTK_CONTAINER (window), grid);
    
      menumodel = g_menu_new ();
      g_menu_append (menumodel, "New", "app.new");
      g_menu_append (menumodel, "About", "win.about");
    
      submenu = g_menu_new ();
      g_menu_append_submenu (menumodel, "Other", G_MENU_MODEL (submenu));
      g_menu_append (submenu, "Quit", "app.quit");
      gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menubutton), G_MENU_MODEL (menumodel));
    
      about_action = g_simple_action_new ("about", NULL);
      g_signal_connect (about_action, "activate", G_CALLBACK (about_callback),
                        GTK_WINDOW (window));
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (about_action));
    
      gtk_widget_show_all (window);
    }
    
    
    static void
    new_callback (GSimpleAction *simple,
                  GVariant      *parameter,
                  gpointer       user_data)
    {
      g_print ("You clicked \"New\"\n");
    }
    
    static void
    quit_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      GApplication *application = user_data;
    
      g_application_quit (application);
    }
    
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      GSimpleAction *new_action;
      GSimpleAction *quit_action;
    
      new_action = g_simple_action_new ("new", NULL);
      g_signal_connect (new_action, "activate", G_CALLBACK (new_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (new_action));
    
      quit_action = g_simple_action_new ("quit", NULL);
      g_signal_connect (quit_action, "activate", G_CALLBACK (quit_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
    }
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
      return status;
    }
cs: #include &lt;gtk/gtk.h&gt;
    
    /* Funkce zpětného volání pro činnost Zpět */
    static void
    about_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      g_print ("You clicked \"About\"\n");
    }
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GMenu *submenu;
      GtkWidget *grid;
      GMenu *menumodel;
      GtkWidget *window;
      GtkWidget *menubutton;
      GSimpleAction *about_action;
    
      window = gtk_application_window_new (app);
      grid = gtk_grid_new ();
    
      gtk_window_set_title (GTK_WINDOW (window), "MenuButton Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
    
      menubutton = gtk_menu_button_new ();
      gtk_widget_set_size_request (menubutton, 80, 35);
    
      gtk_grid_attach (GTK_GRID (grid), menubutton, 0, 0, 1, 1);
      gtk_container_add (GTK_CONTAINER (window), grid);
    
      menumodel = g_menu_new ();
      g_menu_append (menumodel, "New", "app.new");
      g_menu_append (menumodel, "About", "win.about");
    
      submenu = g_menu_new ();
      g_menu_append_submenu (menumodel, "Other", G_MENU_MODEL (submenu));
      g_menu_append (submenu, "Quit", "app.quit");
      gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menubutton), G_MENU_MODEL (menumodel));
    
      about_action = g_simple_action_new ("about", NULL);
      g_signal_connect (about_action, "activate", G_CALLBACK (about_callback),
                        GTK_WINDOW (window));
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (about_action));
    
      gtk_widget_show_all (window);
    }
    
    
    static void
    new_callback (GSimpleAction *simple,
                  GVariant      *parameter,
                  gpointer       user_data)
    {
      g_print ("You clicked \"New\"\n");
    }
    
    static void
    quit_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      GApplication *application = user_data;
    
      g_application_quit (application);
    }
    
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      GSimpleAction *new_action;
      GSimpleAction *quit_action;
    
      new_action = g_simple_action_new ("new", NULL);
      g_signal_connect (new_action, "activate", G_CALLBACK (new_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (new_action));
    
      quit_action = g_simple_action_new ("quit", NULL);
      g_signal_connect (quit_action, "activate", G_CALLBACK (quit_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
    }
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
      return status;
    }

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class Application {
    
        //create the application
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.myapp',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            //connect to 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        //create the UI (in this case it's just the ApplicationWindow)
        _buildUI() {
            this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                       window_position: Gtk.WindowPosition.CENTER,
                                                       title: "MenuButton Example" });
            this._window.set_default_size(600, 400);
            this.grid = new Gtk.Grid();
            this._window.add(this.grid);
    
    
            this._menuButton = new Gtk.MenuButton();
            this.grid.attach(this._menuButton, 0, 0, 1, 1 );
            this.menu = Gtk.Menu.new_from_model(this.menuModel);
    
            this.menu.show();
            this._menuButton.set_menu_model (this.menuModel);
            this._menuButton.set_size_request(80, 35);
            this._menuButton.show();
    
            this._window.show_all();
        }
    
        _showNew() {
            print("You clicked \"New\"");
        }
    
        _showAbout() {
            print("You clicked \"About\"");
        }
    
        //create the menu items and connect the signals to the callback functions.
        _initMenus() {
            let newAction = new Gio.SimpleAction({ name: 'new' });
            newAction.connect('activate', () =&gt; { this._showNew(); });
            this.application.add_action(newAction);
    
            let aboutAction = new Gio.SimpleAction({ name: 'about' });
            aboutAction.connect('activate', () =&gt; { this._showAbout(); });
            this.application.add_action(aboutAction);
    
            let quitAction = new Gio.SimpleAction({ name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
             this.application.add_action(quitAction);
    
            this.menuModel = new Gio.Menu();
    
            this.menuItemNew = Gio.MenuItem.new("New", 'app.new');
            this.menuItemAbout = Gio.MenuItem.new("About", 'app.about');
            this.fileMenuItem = Gio.MenuItem.new("Other", null);
    
            this.menuModel.append_item(this.menuItemNew);
            this.menuModel.append_item(this.menuItemAbout);
    
            //submenu
            this.subMenu = new Gio.Menu();
            this.fileMenuItem.set_submenu(this.subMenu);
            this.menuItemQuit = Gio.MenuItem.new("Quit", 'app.quit');
            this.subMenu.append_item(this.menuItemQuit);
            this.menuModel.append_item(this.fileMenuItem);
        }
    
        //callback function for 'activate' signal
        _onActivate() {
            this._window.present();
        }
    
        //callback function for 'startup' signal
        _onStartup() {
            //You must call _initMenus() before calling _buildUI().
            this._initMenus();
            this._buildUI();
        }
    };
    
    //run the application
    let app = new Application();
    app.application.run(ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class Application {
    
        // Vytvoří aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.myapp',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
           // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Vytvoří uživatelské rozhraní (v tomto případě jen ApplicationWindow)
        _buildUI() {
            this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                       window_position: Gtk.WindowPosition.CENTER,
                                                       title: "MenuButton Example" });
            this._window.set_default_size(600, 400);
            this.grid = new Gtk.Grid();
            this._window.add(this.grid);
    
    
            this._menuButton = new Gtk.MenuButton();
            this.grid.attach(this._menuButton, 0, 0, 1, 1 );
            this.menu = Gtk.Menu.new_from_model(this.menuModel);
    
            this.menu.show();
            this._menuButton.set_menu_model (this.menuModel);
            this._menuButton.set_size_request(80, 35);
            this._menuButton.show();
    
            this._window.show_all();
        }
    
        _showNew() {
            print("You clicked \"New\"");
        }
    
        _showAbout() {
            print("You clicked \"About\"");
        }
    
        // Vytvoří položky nabídky a napojí signály na funkce zpětného volání
        _initMenus() {
            let newAction = new Gio.SimpleAction({ name: 'new' });
            newAction.connect('activate', () =&gt; { this._showNew(); });
            this.application.add_action(newAction);
    
            let aboutAction = new Gio.SimpleAction({ name: 'about' });
            aboutAction.connect('activate', () =&gt; { this._showAbout(); });
            this.application.add_action(aboutAction);
    
            let quitAction = new Gio.SimpleAction({ name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
             this.application.add_action(quitAction);
    
            this.menuModel = new Gio.Menu();
    
            this.menuItemNew = Gio.MenuItem.new("New", 'app.new');
            this.menuItemAbout = Gio.MenuItem.new("About", 'app.about');
            this.fileMenuItem = Gio.MenuItem.new("Other", null);
    
            this.menuModel.append_item(this.menuItemNew);
            this.menuModel.append_item(this.menuItemAbout);
    
            // Podnabídka
            this.subMenu = new Gio.Menu();
            this.fileMenuItem.set_submenu(this.subMenu);
            this.menuItemQuit = Gio.MenuItem.new("Quit", 'app.quit');
            this.subMenu.append_item(this.menuItemQuit);
            this.menuModel.append_item(this.fileMenuItem);
        }
    
        // Funkce zpětného volání pro signál "activate"
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup"
        _onStartup() {
            //Před voláním _buildUI() musíte zavolat _initMenus()
            this._initMenus();
            this._buildUI();
        }
    };
    
    // Spustí aplikaci
    let app = new Application();
    app.application.run(ARGV);

note: (itstool) path: note/p
en: You need to be running GNOME 3.6 for the MenuButton to work.
cs: Musíte používat GNOME 3.6 nebo novější, aby widget MenuButton fungoval.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Menubutton Example", application=app)
            self.set_default_size(600, 400)
    
            grid = Gtk.Grid()
    
            # a menubutton
            menubutton = Gtk.MenuButton()
            menubutton.set_size_request(80, 35)
    
            grid.attach(menubutton, 0, 0, 1, 1)
    
            # a menu with two actions
            menumodel = Gio.Menu()
            menumodel.append("New", "app.new")
            menumodel.append("About", "win.about")
    
            # a submenu with one action for the menu
            submenu = Gio.Menu()
            submenu.append("Quit", "app.quit")
            menumodel.append_submenu("Other", submenu)
    
            # the menu is set as the menu of the menubutton
            menubutton.set_menu_model(menumodel)
    
            # the action related to the window (about)
            about_action = Gio.SimpleAction.new("about", None)
            about_action.connect("activate", self.about_callback)
            self.add_action(about_action)
    
            self.add(grid)
    
        # callback for "about"
        def about_callback(self, action, parameter):
            print("You clicked \"About\"")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            #  the actions related to the application
            new_action = Gio.SimpleAction.new("new", None)
            new_action.connect("activate", self.new_callback)
            self.add_action(new_action)
    
            quit_action = Gio.SimpleAction.new("quit", None)
            quit_action.connect("activate", self.quit_callback)
            self.add_action(quit_action)
    
        # callback functions for the actions related to the application
        def new_callback(self, action, parameter):
            print("You clicked \"New\"")
    
        def quit_callback(self, action, parameter):
            print("You clicked \"Quit\"")
            self.quit()
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Menubutton Example", application=app)
            self.set_default_size(600, 400)
    
            grid = Gtk.Grid()
    
            # Tlačítko s nabídkou
            menubutton = Gtk.MenuButton()
            menubutton.set_size_request(80, 35)
    
            grid.attach(menubutton, 0, 0, 1, 1)
    
            # Nabídka se dvěmi akcemi
            menumodel = Gio.Menu()
            menumodel.append("New", "app.new")
            menumodel.append("About", "win.about")
    
            # Podnabídka s jednou akcí pro nabídku
            submenu = Gio.Menu()
            submenu.append("Quit", "app.quit")
            menumodel.append_submenu("Other", submenu)
    
            # Nabídka je nastavena jako nabídka pro MenuButton
            menubutton.set_menu_model(menumodel)
    
            # Akce vztahující se k oknu ("about")
            about_action = Gio.SimpleAction.new("about", None)
            about_action.connect("activate", self.about_callback)
            self.add_action(about_action)
    
            self.add(grid)
    
        # Zpětné volání pro "about"
        def about_callback(self, action, parameter):
            print("You clicked \"About\"")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # Akce vztahující se k aplikaci
            new_action = Gio.SimpleAction.new("new", None)
            new_action.connect("activate", self.new_callback)
            self.add_action(new_action)
    
            quit_action = Gio.SimpleAction.new("quit", None)
            quit_action.connect("activate", self.quit_callback)
            self.add_action(quit_action)
    
        # Funkce zpětného volání pro akce vtahující se k aplikaci
        def new_callback(self, action, parameter):
            print("You clicked \"New\"")
    
        def quit_callback(self, action, parameter):
            print("You clicked \"Quit\"")
            self.quit()
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a MenuButton widget
cs: Užitečné metody pro widget MenuButton

note: (itstool) path: section/p
en: In line 33 the signal <code>"activate"</code> from the action <code>about_action</code> is connected to the callback function <code>about_callback()</code> using <code><var>action</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 33 je signál <code>"activate"</code> od činnosti <code>about_action</code> napojen na funkci zpětného volání <code>about_callback()</code> pomocí <code><var>action</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: section/p
en: The positioning of the menu is determined by the "direction" property of the menu button and the "halign" or "valign" properties of the menu. For example, when the direction is <code>Gtk.ArrowType.DOWN</code> (other option: <code>UP</code>) and the horizontal alignment is <code>Gtk.Align.START</code> (other options: <code>CENTER</code> and <code>END</code>), the menu will be positioned below the button, with the starting edge (depending on the text direction) of the menu aligned with the starting edge of the button. If there is not enough space below the button, the menu is popped up above the button instead. If the alignment would move part of the menu offscreen, it is 'pushed in'.
cs: Umístění nabídky je určeno vlastností <code>"direction"</code> (směr) tlačítka s nabídkou a vlastnostmi <code>"halign"</code> (vodorovné zarovnání) nebo <code>"valign"</code> (svislé zarovnání) nabídky. Například, když je směr <code>Gtk.ArrowType.DOWN</code> (další volba je <code>UP</code>) a vodorovné zarovnání je <code>Gtk.Align.START</code> (další volby jsou <code>CENTER</code> a <code>END</code>), bude nabídka umístěna pod tlačítkem s počáteční hranou (v závislosti na směru textu) nabídky zarovnanou s počáteční hranou tlačítka. Jestliže pod tlačítkem není dostatek místa, vyskočí místo toho nabídka nahoru. Když by zarovnání posunulo část nabídky mimo obrazovku, natlačí se do viditelné části.

note: (itstool) path: section/p
en: In the case of vertical alignment, the possible ArrowType directions are <code>LEFT</code> and <code>RIGHT</code> and the vertical alignment is again <code>START</code>, <code>CENTER</code> or <code>END</code>.
cs: V případě svislého zarovnání jsou možné směry šipky <code>LEFT</code> a <code>RIGHT</code> a svislé zarovnání je <code>START</code>, <code>CENTER</code> nebo <code>END</code>.

note: (itstool) path: section/p
en: <code>set_align_widget(alignment)</code> and <code>set_direction(direction)</code> can be used to set these properties.
cs: K nastavení těchto vlastností můžete použít <code>set_align_widget(zarovnání)</code> a <code>set_direction(směr)</code>.

note: (itstool) path: page/code
en: public class MyWindow : Gtk.ApplicationWindow {
    
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "MenuButton Example");
    		this.set_default_size (600, 400);
    		var grid = new Gtk.Grid ();
    
    		var menubutton = new Gtk.MenuButton();
    		menubutton.set_size_request (80, 35);
    
    		var menumodel = new Menu ();
    		menumodel.append ("New", "app.new");
    		menumodel.append ("About", "win.about");
    
    		/* We create the last item as a MenuItem, so that
    		 * a submenu can be appended to this menu item.
    		 */
    		var submenu = new Menu ();
    		menumodel.append_submenu ("Other", submenu);
    		submenu.append ("Quit", "app.quit");
    		menubutton.set_menu_model (menumodel);
    
    		var about_action = new SimpleAction ("about", null);
    		about_action.activate.connect (this.about_cb);
    		this.add_action (about_action);
    
    		this.add(grid);
    		grid.attach(menubutton, 0, 0, 1, 1);
    	}
    
    	void about_cb (SimpleAction simple, Variant? parameter) {
    		print ("You clicked \"About\"\n");
    	}
    }
    
    public class MyApplication : Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show_all ();
    	}
    
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    
    	/* Override the 'startup' signal of GLib.Application. */
    	protected override void startup () {
    		base.startup ();
    
    		var new_action = new SimpleAction ("new", null);
    		new_action.activate.connect (this.new_cb);
    		this.add_action (new_action);
    
    		var quit_action = new SimpleAction ("quit", null);
    		quit_action.activate.connect (this.quit);
    		this.add_action (quit_action);
    	}
    
    	void new_cb (SimpleAction simple, Variant? parameter) {
    		print ("You clicked \"New\"\n");
    	}
    }
    
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: public class MyWindow : Gtk.ApplicationWindow {
    
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "MenuButton Example");
    		this.set_default_size (600, 400);
    		var grid = new Gtk.Grid ();
    
    		var menubutton = new Gtk.MenuButton();
    		menubutton.set_size_request (80, 35);
    
    		var menumodel = new Menu ();
    		menumodel.append ("New", "app.new");
    		menumodel.append ("About", "win.about");
    
    		/* Poslední položku vytvoříme jako  MenuItem, takže
    		 * tato podnabídka může být připojena k této položce
    		 * nabídky
    		 */
    		var submenu = new Menu ();
    		menumodel.append_submenu ("Other", submenu);
    		submenu.append ("Quit", "app.quit");
    		menubutton.set_menu_model (menumodel);
    
    		var about_action = new SimpleAction ("about", null);
    		about_action.activate.connect (this.about_cb);
    		this.add_action (about_action);
    
    		this.add(grid);
    		grid.attach(menubutton, 0, 0, 1, 1);
    	}
    
    	void about_cb (SimpleAction simple, Variant? parameter) {
    		print ("You clicked \"About\"\n");
    	}
    }
    
    public class MyApplication : Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show_all ();
    	}
    
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    
    	/* Přepíše signál "activate" z GLib.Application */
    	protected override void startup () {
    		base.startup ();
    
    		var new_action = new SimpleAction ("new", null);
    		new_action.activate.connect (this.new_cb);
    		this.add_action (new_action);
    
    		var quit_action = new SimpleAction ("quit", null);
    		quit_action.activate.connect (this.quit);
    		this.add_action (quit_action);
    	}
    
    	void new_cb (SimpleAction simple, Variant? parameter) {
    		print ("You clicked \"New\"\n");
    	}
    }
    
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

[ctx: text]
note: (itstool) path: info/title
en: Message board (C)
cs: Vývěska (C)

note: (itstool) path: info/desc
en: A simple program using WebKitGTK+ and the DOM.
cs: Jednoduchý program používající WebKitGTK+ a DOM.

note: (itstool) path: page/title
en: Message board
cs: Vývěska

note: (itstool) path: item/p
en: How to display a web page with WebKit.
cs: Jak zobrazit webovou stránku pomocí jádra WebKit.

note: (itstool) path: item/p
en: How to manipulate the contents of a web page using WebKit's DOM functions.
cs: Jak pracovat s obsahem webové stránky pomocí funkcí DOM jádra WebKit.

note: (itstool) path: synopsis/p
en: This tutorial assumes you are familiar with the C programming language and have a basic understanding of GTK+, including how to create and place widgets and how to connect callback functions to signals. See <link xref="image-viewer.c"/> to learn the basics of GTK+.
cs: Tato lekce předpokládá, že máte znalosti programování v jazyce C a základní povědomí o GTK+, včetně toho, jak vytvořit a umístit widgety a jak připojit funkce zpětného volání k signálům. Viz <link xref="image-viewer.c"/> ohledně výuky základů GTK+.

note: (itstool) path: section/p
en: The GNOME platform includes WebKitGTK+, built on top of the powerful WebKit HTML framework. WebKit is used throughout GNOME, not just to view web pages on the Internet, but also to create rich user interfaces that can be easily styled with CSS.
cs: Součástí platformy GNOME je WebKitGTK+ vycházející z mocné základní konstrukce WebKit pro HTML. WebKit je používán napříč celým GNOME, ne jen pro zobrazení webových stránek z Internetu, ale také k vytváření vizuálně bohatého uživatelského rozhraní, které lze jednoduše stylovat pomocí CSS.

note: (itstool) path: section/p
en: In this tutorial, you will create a simple message board using WebKit. The message board will allow you to enter some text and have it added to a list of messages in HTML. Before you begin, you need to set up a project in Anjuta.
cs: V této lekci vytvoříme jednoduchou vývěsku pomocí knihovny WebKit. Vývěska bude umožňovat vkládat text a přidávat jej do seznamu zpráv v HTML. Než začneme, potřebujeme vytvořit projekt v IDE Anjuta.

note: (itstool) path: item/p
en: In Anjuta, click <guiseq><gui>File</gui><gui>New</gui> <gui>Project</gui></guiseq> to open the new project assistant.
cs: Ve studiu Anjuta klikněte na <guiseq><gui>Soubor</gui> <gui>Nový</gui> <gui>Projekt</gui></guiseq>, aby se otevřel průvodce novým projektem.

note: (itstool) path: item/p
en: Select <gui>GTK+ (simple)</gui> on the <gui>C</gui> tab, and click <gui>Continue</gui>.
cs: Vyberte <gui>GTK+ (jednoduchý)</gui> na kartě <gui>C</gui> a klikněte na <gui>Pokračovat</gui>.

note: (itstool) path: item/p
en: Fill out your details on the <gui>Basic information</gui> page. Use <input>message-board</input> for the project name. Click <gui>Continue</gui>.
cs: Na stránce <gui>Základní informace</gui> vyplňte své údaje. Jako název projektu použijte <input>message-board</input>. Klikněte na <gui>Pokračovat</gui>.

note: (itstool) path: item/p
en: Disable the <gui>Use GtkBuilder for user interface</gui> option as this tutorial builds the user-interface manually.
cs: Vypněte volbu <gui>Použít GtkBuilder k tvorbě uživatelského rozhraní</gui>, protože jej chceme v této lekci vytvořit ručně.

note: (itstool) path: item/p
en: You need to tell Anjuta you're using WebKitGTK+ on this project. On the <gui>Project options</gui> page, select <gui>Configure external packages</gui>. Click <gui>Continue</gui>. On the <gui>Configure external packages</gui> page, check <gui>webkitgtk-3.0</gui>.
cs: Potřebujete vývojářskému studiu Anjuta říct, že ve svém projektu používáte WebKitGTK+. Na stránce <gui>Volby projektu</gui> vyberte <gui>Konfigurovat externí balíčky</gui>. Klikněte na <gui>Pokračovat</gui> a na stránce <gui>Konfigurace externích balíčků</gui> zaškrtněte <gui>webkitgtk-3.0</gui>.

note: (itstool) path: section/p
en: 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:
cs: Po té, co projdete průvodcem nového projektu, otevřete <file>src/main.c</file> na kartě <gui>Projekt</gui> nebo <gui>Soubor</gui>. Anjuta jej vyplní nějakým základním kódem GTK+ ze šablony. Protože vytváříte projekt s knihovnou WebKit, potřebujete nejdříve vložit příslušné hlavičkové soubory. Za řádek, který vkládá <code>gtk/gtk.h</code> přidejte následující řádek:

note: (itstool) path: section/p
en: 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>.
cs: Ověřte, že vše, co máte doposud hotovo, funguje. Klikněte na <guiseq><gui>Sestavit</gui> <gui>Sestavit projekt</gui></guiseq> nebo jen zmáčkněte <keyseq><key>Shift</key> <key>F7</key></keyseq>. Při prvním sestavení budete dotázáni na některé volby konfigurace. Stačí přijmout výchozí hodnoty a kliknout na <gui>Spustit</gui>.

note: (itstool) path: section/p
en: 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.
cs: Nyní byste měli být schopni program spustit. Klikněte na <guiseq><gui>Spustit</gui> <gui>Spustit</gui></guiseq> nebo jen zmáčkněte <key>F3</key>. Měli byste spatřit prázdné okno.

note: (itstool) path: section/title
en: Lay out your window and web view
cs: Rozvržení vašeho okna a webového zobrazení

note: (itstool) path: section/p
en: Now that you can show a window, it's time to start working with WebKit. For this tutorial, you'll create a text entry and a web view and pack them both into a window. Find the function <code>create_window</code> and replace it with the following:
cs: Nyní, když můžete zobrazit okno, je načase začít pracovat s knihovnou WebKit. V této lekci vytvoříte textové vstupní pole a webové zobrazení a obojí zabalíte do okna. Najděte funkci <code>create_window</code> a nahraďte ji následujícím:

note: (itstool) path: section/p
en: You first create a <code>GtkWindow</code> object and set its title and default size. You also connect the <code>gtk_main_quit</code> function to the <code>delete-event</code> signal. The <code>delete-event</code> signal is emitted when the window is closed. The <code>gtk_main_quit</code> function is part of GTK, and it quits the application.
cs: Nejprve vytvoříte objekt <code>GtkWindow</code> a nastavíte jeho název do záhlaví a výchozí velikost. Rovněž napojíte funkci <code>gtk_main_quit</code> na signál <code>"delete-event"</code>. Tento signál je vyslán, když je okno zavřeno. Funkce <code>gtk_main_quit</code> je součástí GTK a ukončí aplikaci.

note: (itstool) path: section/p
en: 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.
cs: Pak vytvoříte svislý box a přidáte jej do okna. Okno může obsahovat jen jediný synovský widget, takže potřebujete box, abyste mohli přidat víc widgetů. Druhým argumentem u funkce <code>gtk_box_new</code> se nastaví velikost odsazení (v pixelech) mezi jednotlivými potomky a následující řádek vloží 6pixelový okraj okolo toho všeho.

note: (itstool) path: section/p
en: 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.
cs: Následně vytvoříte objekt <code>GtkEntry</code> a zabalíte jej do boxu. Třetí argument u <code>gtk_box_pack_start</code> určují, že vstupní pole by nemělo zabírat žádné místo navíc, které je v boxu dostupné. Čtvrtý argument je velikost odsazení okolo vstupního pole. V tomto případě jej nastavte na nulu, protože o odsazení se postará box.

note: (itstool) path: section/p
en: 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.
cs: Než přidáte webové zobrazení, musíte vytvořit okno s posuvníky, do kterého jej pak vložíte. Okno s posuvníky umístí v případě potřeby doprava a dolů posuvníky a zabrání vašemu webovému zobrazení, aby zaplnilo celou obrazovku. Tentokrát funkci <code>gtk_box_pack_start</code> předejte <code>TRUE</code> a <code>TRUE</code>, aby umožnila oknu s posuvníky (a tím webovému zobrazení) použít dodatečné místo dostupné v boxu.

note: (itstool) path: section/p
en: 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:
cs: Nakonec vytvoříte <code>WebKitWebView</code> a přidáte jej do okna s posuvníky. Potom načtěte úplně základní stránku v HTML do webového zobrazení zavoláním <code>webkit_web_view_load_string</code> s následujícími parametry:

note: (itstool) path: item/p
en: The view itself. Because <code>view</code> is typed as a <code>GtkWidget*</code>, you have to use <code>WEBKIT_WEB_VIEW</code> to safely cast the object.
cs: Vlastní zobrazení. Protože <code>view</code> je typováno jako <code>GtkWidget*</code>, musíte požít <code>WEBKIT_WEB_VIEW</code>, aby se objekt bezpečně přetypoval.

note: (itstool) path: item/p
en: The simplest HTML file you could possibly write.
cs: Nejjednodušší soubor HTML, který byste mohli napsat.

note: (itstool) path: item/p
en: The MIME type of the content you provided. In this case, you're using plain HTML.
cs: Typ MIME obsahu, který poskytujete. V tomto případě používáte prosté HTML.

note: (itstool) path: item/p
en: The character encoding of the content you provided. Although you only used ASCII characters, it's a good idea to specify UTF-8. UTF-8 is used as the default encoding throughout the GNOME platform.
cs: Kódování znaků v obsahu, který poskytujete. I když použijete jen znaky ASCII, je dobrým pravidlem zadat UTF-8. UTF-8 je totiž používáno jako výchozí kódování napříč celou platformou GNOME.

note: (itstool) path: item/p
en: The base URI. You don't need it in this simple example, but you might want to provide a <sys>file:</sys> URI if you add images or other features where you want to use relative URI references.
cs: Základní adresa URI. V tomto příkladu ji nepotřebujeme, ale možná budete chtít zadat URI <sys>file:</sys>, kdybyste přidali obrázky nebo jinou funkčnost, ve které chcete použít relativní odkazy URI.

note: (itstool) path: note/p
en: 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.
cs: Pokaždé, když přidáte widget, musíte pro něj zavolat <code>gtk_widget_show</code>, aby byl viditelný. Když zavoláte <code>gtk_widget_show_all</code> pro kontejnerový widget, jako je <code>GtkBox</code>, zobrazí GTK+ automaticky všechny widgety uvnitř kontejneru do libovolné hloubky. Občas nemusíte chtít <code>gtk_widget_show_all</code> volat, třeba když chcete dynamicky skrývat a zobrazovat některé widgety v reakci na události.

note: (itstool) path: section/p
en: 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>.)
cs: Nakonec musíme v boxu zavolat <code>gtk_widget_show_all</code>, jinak nebude žádný vytvořený widget viditelný. (Okno je zobrazeno ve funkci <code>main</code> pomocí <code>gtk_widget_show</code>.)

note: (itstool) path: section/p
en: 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.
cs: Sestavte a spusťte vývěsku znovu. Měli byste vidět okno s textovým vstupním polem a webové zobrazení. Zatím to nic nedělá, protože vstupní pole a webové zobrazení o sobě navzájem nic neví.

note: (itstool) path: section/title
en: Hook up signals
cs: Zaháčkování signálů

note: (itstool) path: section/p
en: 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:
cs: Nyní chcete vývěsku naučit něco <em>udělat</em>, když zadáte text do textového vstupního pole. To se provede tak, že se napojí funkce zpětného volání na signál <code>"activate"</code> objektu <code>entry</code>. GTK+ vyšle signále <code>"activate"</code>, kdykoliv uživatel ve vstupním poli zmáčkne <key>Enter</key>. Následující kód přidejte do <code>create_window</code> kamkoliv za definici <code>entry</code> a <code>view</code>:

note: (itstool) path: section/p
en: You then have to actually define <code>entry_activate_cb</code>. Define it as follows, anywhere above <code>create_window</code>:
cs: Potom můžete totiž definovat <code>entry_activate_cb</code>. Nadefinujte jej následovně kdekoliv nad <code>create_window</code>:

note: (itstool) path: section/p
en: 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.
cs: První věc, kterou uděláte, je, že získáte objekt <code>WebKitDOMDocument</code>, který představuje dokument HTML zobrazený ve widgetu <code>view</code>. Třídy a metody DOM v knihovně WebKit umožňují procházet a upravovat dokument HTML a fungují velmi podobně jako API k DOM, které můžete znát z jazyka JavaScript.

note: (itstool) path: section/p
en: 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.
cs: Jakmile máme dokument, chceme se dostat k prvku <code>body</code>, protože do něj můžeme přidat prvky <code>div</code>. Funkce <code>webkit_dom_document_query_selector</code> umožňuje najít prvek v dokumentu pomocí selektorů CSS. Tím si ušetříte psaní jednotvárných smyček pro procházení dokumentu.

note: (itstool) path: section/p
en: 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.
cs: V dalším kroku vytvoříme nový prvek <code>div</code>, ve kterém bude zpráva. Každý prvek, který vytvoříte, musí být připojen do dokumentu, takže funkce, která prvky vytváří, přebírá jako první argument <code>WebKitDOMDocument</code>. Pak nastavíte textový obsah prvku na obsah z textového vstupního pole. Protože <code>gtk_entry_get_text</code> vrací <code>const gchar*</code>, nemusíte výsledek uvolňovat z paměti.

note: (itstool) path: section/p
en: 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.
cs: Nakonec přidáme nový prvek <code>div</code> do těla a vymažeme textové vstupní pole, takže můžete napsat něco dalšího. Sestavte a spusťte program znovu a otestujte si jej.

note: (itstool) path: section/title
en: Make it look better with CSS
cs: Vytvoření hezčího vzhledu pomocí CSS

note: (itstool) path: section/p
en: 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.
cs: V tuto chvíli je program plně funkční, ale ne moc hezký. Můžeme ostylovat zobrazení zpráv pomocí CSS, podobně jako to můžete udělat s kteroukoliv stránkou v HTML. Existuje mnoho způsobů, jak připojit stylopis do stránky: Mohli byste jej přidat do počátečního dokumentu HTML. Mohli byste jej vložit pomocí atributu <code>style</code> v prvku <code>div</code>. Mohli byste jej i sestrojit pomoci API k DOM.

note: (itstool) path: section/p
en: 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.
cs: V této lekci připojíme CSS pomocí vlastnosti <code>user-stylesheet-uri</code> objektu <code>WebKitWebSetting</code> připojeného do vašeho webového zobrazení. Ve složitějších aplikacích byste asi chtěli soubor HTML ukládat a načítat. Udržením stylopisu mimo HTML znamená, že může měnit styl přímo ve své aplikaci, bez zásahu do uživatelských souborů. Normálně by vám stačilo nainstalovat soubor se stylopisem spolu s vaší aplikací, ale aby pro potřeby této ukázky zůstalo vše uchováno v jednom souboru, použijeme trik nazvaný datová URI. Nejprve nadefinujeme CSS jako statický řetězec poblíž začátku vašeho souboru.

note: (itstool) path: section/p
en: 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.
cs: Vše, co máme v tomto příkladu, jsou prvky <code>div</code> uvnitř prvku <code>body</code>. Kdybyste vytvořili složitější HTML, mohli byste použít cokoliv by CSS bylo potřeba. Jestli jste s CSS obeznámeni, můžete si opravdu zkusit nějaké změny, aby se vám vzhled víc líbil.

note: (itstool) path: section/p
en: 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.
cs: Aby se použilo CSS, nastavte <code>user-stylesheet-uri</code> ve funkci <code>create_window</code> kdekoliv za definicí <code>view</code>.

note: (itstool) path: section/p
en: Also, make sure to add variable declarations for <code>tmp</code> and <code>css</code> to the top of <code>create_window</code>.
cs: Rovněž zajistěte přidání deklarací proměnných pro <code>tmp</code> a <code>css</code> na začátku <code>create_window</code>.

note: (itstool) path: section/p
en: 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.
cs: Datová URI začíná <sys>data:</sys> a některými informacemi o typu obsahu a kódování dat. Skutečná data následují za čárkou, v tomto případě zakódovaná v Base64. Narozdíl od jiných schémat URI, jako je <sys>http:</sys>, <sys>ftp:</sys> a <sys>file:</sys>, schéma URI <sys>data:</sys> nespecifikuje, kde najít soubor k načtení. Místo toho poskytuje rovnou celý obsah souboru.

note: (itstool) path: section/p
en: 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.
cs: Předchozí kód nejprve zakóduje vaši definici CSS v Base64 a pak ji zkombinuje s pevným řetězcem, aby vytvořil datovou URI. Funkce <code>g_strconcat</code> může přebírat libovolný počet řetězcových argumentů a spojit je dohromady, proto jí musíte jako poslední argument předat <code>NULL</code>, aby věděla kdy přestat. A až stylopis správně nastavíte, nezapomeňte uvolnit tyto dočasné řetězce z paměti.

note: (itstool) path: section/p
en: 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.
cs: Sestavte a spusťte program znovu. Měl by fungovat úplně stejně jako na konci předchozí části, vyjma toho, že zprávy jsou hezky ostylované pomocí okrajů a pozadí s jemným přechodem.

note: (itstool) path: section/title
en: Learn more
cs: Jak se naučit více

note: (itstool) path: section/p
en: This tutorial showed you how to create a basic application using GTK+ and WebKit, including showing a document and manipulating its contents. To create a real application, you probably want to do a little bit more. Try adding features on your own. Here are a few ideas:
cs: V této lekci jsme si ukázali, jak vytvořit základní aplikaci pomocí knihoven GTK+ a WebKit, včetně zobrazení dokumentu a manipulace s jeho obsahem. Pro vytvoření reálné aplikace byste nejspíše museli udělat něco navíc. Zkuste si přidat vlastní funkčnost. Zde je pár nápadů:

note: (itstool) path: item/p
en: If you're comfortable with CSS, try changing the style of the message display. CSS is easy to get started with, but increasingly more powerful. There is a wealth of CSS tutorials on the Internet, and just about everything you can do on the web, you can do in this application.
cs: Pokud máte CSS rádi, zkuste si změnit styl zobrazených zpráv. S CSS se snadno začíná, ale i roste k mocnějšímu využití. Na Internetu je k dispozici nepřeberné množství výukových materiálů k CSS a téměř vše, co můžete udělat na webu, můžete udělat i v této aplikaci.

note: (itstool) path: item/p
en: Right now, you lose all your messages whenever you close the message board. Try saving the HTML contents after each post, and loading the saved file (if it exists) on startup.
cs: V současné stavu přijdete o všechny své zprávy, když vývěsku zavřete. Zkuste obsah v HTML ukládat po každém příspěvku a načítat jej z uloženého souboru (když existuje) při spuštění.

note: (itstool) path: item/p
en: 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.
cs: Až budete mít své zprávy uchované po dlouhou dobu, možná vás začne zajímat, kdy vlastně byly zveřejněny. Přidejte ke každé zprávě při jejím zveřejnění časové razítko. Možná budete potřebovat vytvořit další synovský prvek <code>div</code> s jinou třídou, abyste to mohli ostylovat pomocí CSS.

note: (itstool) path: item/p
en: This program keeps messages around forever. Think about ways you could allow the user to delete messages. Perhaps you want messages to disappear automatically after they're too old, or after there are a certain number of messages before them. Or you could add a link in each message to delete it. You could even override the context menu when you right-click on a message. These features involve exploring WebKit's DOM API more.
cs: Tento program uchovává zprávy navždy. Popřemýšlejte o způsobu, jak by uživatel mohl zprávy mazat. Třeba můžete chtít, aby zprávy samy mizely, když jsou příliš staré nebo když množství zpráv před nimi dosáhne určitého počtu. Nebo můžete ke každé zprávě přidat odkaz na její smazání. Mohli byste také přepsat kontextovou nabídku, která se objeví po kliknutí pravým tlačítkem. Tyto funkce znamenají hlubší prozkoumání API k DOM knihovny WebKit.

note: (itstool) path: info/desc
en: A message window
cs: Okno se zprávou

note: (itstool) path: page/p
en: A modal message dialog which can cause the world to explode.
cs: Modální dialogové okno se zprávou, které způsobí, že svět vybuchne.

note: (itstool) path: note/p
en: To test out the application once it has started running, you can click on the "Message Dialog" tab that appears in the top menubar of the screen.
cs: Když chcete aplikaci otestovat, stačí po jejím spuštění kliknout na nabídku <gui>Message Dialog</gui>, která se objeví v horní liště obrazovky.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Callback function in which reacts to the "response" signal from the user in
     * the message dialog window.
     * This function is used to interact with the user in the terminal.
     */
    static void
    on_response (GtkDialog *dialog,
                 gint       response_id,
                 gpointer   user_data)
    {
      /* If the button clicked gives response OK (response_id being -5) */
      if (response_id == GTK_RESPONSE_OK) 
         g_print ("*boom*\n");
    
      /* If the button clicked gives response CANCEL (response_id being -6) */
      else if (response_id == GTK_RESPONSE_CANCEL)
         g_print ("good choice\n");
    
      /* If the message dialog is destroyed (for example by pressing escape) */
      else if (response_id == GTK_RESPONSE_DELETE_EVENT)
         g_print ("dialog closed or cancelled\n");
    
      /* Destroy the dialog after one of the above actions have taken place */
      gtk_widget_destroy (GTK_WIDGET (dialog));
    
    }
    
    
    
    /* Callback function for the response signal "activate" related to the SimpleAction
     * message_action.
     * This function is used to cause the message dialog window to popup.
     */
    static void
    message_cb (GSimpleAction *simple,
                GVariant      *parameter,
                gpointer       user_data)
    {
       /* the parent variable in this case represents the window */
       GtkWidget *message_dialog;
       GtkWindow *parent = user_data;
       
       /* Create a new message dialog, and set the parameters as follows:
        * Dialog Flags - make the constructed dialog modal 
        * (modal windows prevent interaction with other windows in the application)
        * Message Type - nonfatal warning message
        * Buttons Type - use the ok and cancel buttons
        * message_format - text that you want the user to see in the window 
        */
       message_dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL, 
                                                GTK_MESSAGE_WARNING, 
                                                GTK_BUTTONS_OK_CANCEL, 
                                                "This action will cause the universe to stop existing.");
    
       gtk_widget_show_all (message_dialog);
    
       g_signal_connect (GTK_DIALOG (message_dialog), "response", 
                        G_CALLBACK (on_response), NULL);
    
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *label;
    
      GSimpleAction *message_action;
    
      /* Create a window with a title and a default size */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "GMenu Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 400, 200);
    
      /* Create a label and add it to the window */
      label = gtk_label_new ("This application goes boom!");
      gtk_container_add (GTK_CONTAINER (window), label);
    
      /* Create a new simple action, giving it a NULL parameter type. It will 
       * always be NULL for actions invoked from a menu. (e.g clicking on an "ok" 
       * or "cancel" button)
       */
      message_action = g_simple_action_new ("message", NULL); 
    
      /* Connect the "activate" signal to the appropriate callback function */
      g_signal_connect (message_action, "activate", G_CALLBACK (message_cb), 
                        GTK_WINDOW (window));
    
      /* Adds the message_action to the overall action map. An Action map is an 
       * interface that contains a number of named GAction instances 
       * (such as message_action) 
       */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (message_action));
    
      gtk_widget_show_all (window);
    }
    
    
    
    /* Callback function for the response signal "activate" from the "quit" action 
     * in the function directly below.
     */ 
    static void
    quit_cb (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
      GApplication *application = user_data;
    
      g_application_quit (application);
    }
    
    
    
    /* Startup function for the menu we are creating in this sample */
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      GMenu *menu;
      GSimpleAction *quit_action;
    
      /* Initialize the GMenu, and add a menu item with label "Message" and action 
       * "win.message". Also add another menu item with label "Quit" and action 
       * "app.quit" 
       */
      menu = g_menu_new ();
      g_menu_append (menu, "Message", "win.message");
      g_menu_append (menu, "Quit", "app.quit");
    
      /* Create a new simple action for the application. (In this case it is the 
       * "quit" action.
       */
      quit_action = g_simple_action_new ("quit", NULL);
    
      /* Ensure that the menu we have just created is set for the overall application */
      gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (menu));
    
      g_signal_connect (quit_action, 
                        "activate", 
                        G_CALLBACK (quit_cb), 
                        app);
    
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
    
    }
    
    
    
    /* Startup function for the application */
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Funkce zpětného volání reagující na signál "response" od uživatele
     * v dialogovém okně se zprávou
     * Tato funkce se používá ke komunikaci s uživatelem v terminálu
     */
    static void
    on_response (GtkDialog *dialog,
                 gint       response_id,
                 gpointer   user_data)
    {
      /* Když kliknutí tlačítko odpoví OK (response_id je -5) */
      if (response_id == GTK_RESPONSE_OK) 
         g_print ("*boom*\n");
    
      /* Když kliknuté tlačítko odpoví CANCEL (response_id je -6) */
      else if (response_id == GTK_RESPONSE_CANCEL)
         g_print ("good choice\n");
    
      /* Když je dialogové okno zrušeno (například zmáčknutím Esc) */
      else if (response_id == GTK_RESPONSE_DELETE_EVENT)
         g_print ("dialog closed or cancelled\n");
    
      /* Zlikviduje dialogové okno po té, co se uskutečnila jedna z akcí výše */
      gtk_widget_destroy (GTK_WIDGET (dialog));
    
    }
    
    
    
    /* Funkce zpětného volání pro signál "activate" náležející widgetu
     * SimpleAction message_action
     * Tato funkce se použije ke zobrazení dialogového okna se zprávou
     */
    static void
    message_cb (GSimpleAction *simple,
                GVariant      *parameter,
                gpointer       user_data)
    {
       /* Proměnná parent v tomto případě představuje okno */
       GtkWidget *message_dialog;
       GtkWindow *parent = user_data;
       
       /* Vytvoří nové dialogové okno se zprávou a nastaví jeho parametry následovně:
        * příznaky - zajistí modální režim
        * (modální okno brání v interakci s ostatními okny aplikace)
        * typ zprávy - nekritická varovná zpráva
        * typ tlačítek - použije tlačítka OK a Cancel
        * zpráva - text, který uživatel v dialogovém okně uvidí
        */
       message_dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL, 
                                                GTK_MESSAGE_WARNING, 
                                                GTK_BUTTONS_OK_CANCEL, 
                                                "This action will cause the universe to stop existing.");
    
       gtk_widget_show_all (message_dialog);
    
       g_signal_connect (GTK_DIALOG (message_dialog), "response", 
                        G_CALLBACK (on_response), NULL);
    
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *label;
    
      GSimpleAction *message_action;
    
      /* Vytvoří okno s názvem a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "GMenu Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 400, 200);
    
      /* Vytvoří popisek a přidá jej do okna */
      label = gtk_label_new ("This application goes boom!");
      gtk_container_add (GTK_CONTAINER (window), label);
    
      /* Vytvoří novou jednoduchou akci, jako parametr type ji předá NULL. Ten
       * bude vždy NULL pro akce vyvolané z nabídky (například kliknutí na tlačítko
       * "ok"  nebo "cancel")
       */
      message_action = g_simple_action_new ("message", NULL); 
    
      /* Napojí signál "activate" na příslušnou funkci zpětného volání */
      g_signal_connect (message_action, "activate", G_CALLBACK (message_cb), 
                        GTK_WINDOW (window));
    
      /* Přidá message_action do celkové mapy akcí. Mapa akcí je rozhraní, které
       * obsahuje řadu pojmenovaných instancí GAction (jako je message_action) 
       */
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (message_action));
    
      gtk_widget_show_all (window);
    }
    
    
    
    /* Funkce zpětného volání pro signál "activate" od akce "quit"
     * ve funkci hned za touto
     */ 
    static void
    quit_cb (GSimpleAction *simple,
             GVariant      *parameter,
             gpointer       user_data)
    {
      GApplication *application = user_data;
    
      g_application_quit (application);
    }
    
    
    
    /* Spouštěcí funkce pro nabídku, kterou vytváříme v této ukázce */
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      GMenu *menu;
      GSimpleAction *quit_action;
    
      /* Inicializuje GMenu a přidá do něj položku s textem "Message" a akcí
       * "win.message". Přidá také další položku s textem "Quit" a akcí
       * "app.quit" 
       */
      menu = g_menu_new ();
      g_menu_append (menu, "Message", "win.message");
      g_menu_append (menu, "Quit", "app.quit");
    
      /* Vytvoří novou jednoduchou akci pro aplikaci (v tomto případě do je
       * akce "quit"
       */
      quit_action = g_simple_action_new ("quit", NULL);
    
      /* Zajistí, že právě vytvořená nabídka bude bude pro celou aplikaci */
      gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (menu));
    
      g_signal_connect (quit_action, 
                        "activate", 
                        G_CALLBACK (quit_cb), 
                        app);
    
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
    
    }
    
    
    
    /* Spouštecí funkce aplikace */
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: info/desc
en: A popup message attached to a window
cs: Vyskakovací zpráva svázaná s oknem

note: (itstool) path: page/p
en: A MessageDialog is a modal message dialog, which means a popup that you have to respond to before you get back to what you were doing in the window that it's attached to. This one can cause the world to explode (or at least it says that it can). To make the popup appear when you run this sample, click on "Message" inside of its application menu -- that's the menu that appears when you click on an application's name in the upper-left screen corner, next to Activities.
cs: <code>MessageDialog</code> je modální dialogové okno, což znamená že na vyskočení okna musíte nějak zareagovat, než se můžete vrátit do okna, se kterým je svázané. Toto konkrétní způsobí, že svět vybuchne (nebo to aspoň bude tvrdit). Když budete chtít, aby okno vyskočilo po spuštění této ukázky, klikněte na <gui>Message</gui> v jeho aplikační nabídce – to je nabídka, která se objeví po kliknutí na název aplikace v levém horním rohu obrazovky vedle <gui>Činností</gui>.

note: (itstool) path: note/p
en: The difference between a MessageDialog and a <link xref="dialog.js">Dialog</link> is that a Dialog can contain whatever widgets and content you want to put in it, whereas a MessageDialog is just a convenient way to make popups appear with a basic message and buttons.
cs: Rozdíl mezi widgety <code>MessageDialog</code> a <link xref="dialog.js">Dialog</link> je v tom, že <code>Dialog</code> může obsahovat jakékoliv widgety, které do něj vložíte, zatímco <code>MessageDialog</code> je jen vhodný způsob, jak zobrazit obyčejnou zprávu a tlačítka.

note: (itstool) path: section/code
en: 
    const MessageDialogExample = new Lang.Class ({
        Name: 'MessageDialog Example',
    
        // Create the application itself
        _init: function () {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jsmessagedialog',
                flags: Gio.ApplicationFlags.FLAGS_NONE });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', Lang.bind(this, this._onActivate));
            this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate: function () {
            this._window.present ();
        },
    
        // Callback function for 'startup' signal initializes menus and builds the UI
        _onStartup: function () {
            this._initMenus();
            this._buildUI ();
        },
cs: 
    const MessageDialogExample = new Lang.Class ({
        Name: 'MessageDialog Example',
    
        // Vytvoří vlastní aplikaci
        _init: function () {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jsmessagedialog',
                flags: Gio.ApplicationFlags.FLAGS_NONE });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', Lang.bind(this, this._onActivate));
            this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate: function () {
            this._window.present ();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function () {
            this._initMenus();
            this._buildUI ();
        },

note: (itstool) path: note/p
en: Before we call _buildUI to create the window and the widgets inside it, we need to call _initMenus, which tells GNOME to create the menu. We can put the actual code for _initMenus after the code for _buildUI, since it doesn't matter what order we put them in so long as _initMenus is called first in _onStartup.
cs: Než zavoláme <code>_buildUI</code>, aby se vytvořilo okno a widgety v něm, potřebujeme zavolat funkci <code>_initMenus</code>, která GNOME řekne, aby vytvořilo nabídku. Reálný kód pro <code>_initMenus</code> můžeme vložit za kód <code>_buildUI</code>, jelikož nezáleží na tom, v jakém pořadí jsou vloženy, protože <code>_initMenus</code> je zavoláno jako první z <code>_onStartup</code>.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI: function () {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Gtk.MessageDialog Example",
                default_height: 200,
                default_width: 400 });
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function () {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Gtk.MessageDialog Example",
                default_height: 200,
                default_width: 400 });

note: (itstool) path: section/code
en: 
            // Create a silly warning message and add it to the window
            this.warningLabel = new Gtk.Label ({
                label: "This application goes boom! (Not really.)"});
            this._window.add (this.warningLabel);
cs: 
            // Vytvoří bláznivou varovnou zprávu a přidá ji do okna
            this.warningLabel = new Gtk.Label ({
                label: "This application goes boom! (Not really.)"});
            this._window.add (this.warningLabel);

note: (itstool) path: section/p
en: For this example, all that we have in the window the popup comes out of is a silly warning <link xref="label.js">Label</link>.
cs: V tomto příkladu, je vším, co vyskakovací okno přinese, jen bláznivé varování ve widgetu <link xref="label.js">Label</link>.

note: (itstool) path: section/title
en: Creating the application's menu
cs: Vytvoření nabídky aplikace

note: (itstool) path: section/code
en: 
        // Build the application menu, including the button that calls the dialog
        _initMenus: function() {
            let menu = new Gio.Menu();
            menu.append("Message",'app.message');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            // This pops up a MessageDialog when "Message" is clicked in the menu
            let messageAction = new Gio.SimpleAction ({ name: 'message' });
            messageAction.connect('activate', Lang.bind(this,
                function() {
                    this._showMessageDialog();
                }));
            this.application.add_action(messageAction);
    
            // This closes the window when "Quit" is clicked in the menu
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', Lang.bind(this,
                function() {
                    this._window.destroy();
                }));
            this.application.add_action(quitAction);
        },
cs: 
        // Sestaví aplikační nabídku, včetně položky, které volá dialogové okno
        _initMenus: function() {
            let menu = new Gio.Menu();
            menu.append("Message",'app.message');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            // Tímto se zobrazí MessageDialog, když je v nabídce kliknuto na Message
            let messageAction = new Gio.SimpleAction ({ name: 'message' });
            messageAction.connect('activate', Lang.bind(this,
                function() {
                    this._showMessageDialog();
                }));
            this.application.add_action(messageAction);
    
            // Tímto se zavře okno, když je v nabídce kliknuto na Quit
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', Lang.bind(this,
                function() {
                    this._window.destroy();
                }));
            this.application.add_action(quitAction);
        },

note: (itstool) path: section/p
en: Here, we build the <link xref="gmenu.js">GMenu</link> where we'll be putting the "Message" button which triggers the popup MessageDialog. The GMenu is the menu that appears when you click the application's name in the upper-left corner of the screen, next to the Activities menu. Our menu only has two options in it: Message, and Quit.
cs: Zde sestavíme <link xref="gmenu.js">GMenu</link>, do které ho přidáme položku <gui>Message</gui>, která vyvolá dialogové okno se zprávou. <code>GMenu</code> je nabídka, která se objeví po kliknutí na název aplikace v levém horním rohu obrazovky vedle <gui>Činností</gui>. Naše nabídka má jen dvě položky: <gui>Message</gui> a <gui>Quit</gui>.

note: (itstool) path: section/title
en: Creating the MessageDialog
cs: Vytvoření okna typu MessageDialog

note: (itstool) path: section/code
en: 
        _showMessageDialog: function () {
    
            // Create a modal MessageDialog whose parent is the window
            this._messageDialog = new Gtk.MessageDialog ({
                transient_for: this._window,
                modal: true,
                buttons: Gtk.ButtonsType.OK_CANCEL,
                message_type: Gtk.MessageType.WARNING,
                text: "This action will cause the universe to stop existing." });
    
            this._messageDialog.connect ('response', Lang.bind(this, this._response_cb));
            this._messageDialog.show();
        },
cs: 
        _showMessageDialog: function () {
    
            // Vytvoří modální MessageDialog, jehož rodičem je okno
            this._messageDialog = new Gtk.MessageDialog ({
                transient_for: this._window,
                modal: true,
                buttons: Gtk.ButtonsType.OK_CANCEL,
                message_type: Gtk.MessageType.WARNING,
                text: "This action will cause the universe to stop existing." });
    
            this._messageDialog.connect ('response', Lang.bind(this, this._response_cb));
            this._messageDialog.show();
        },

note: (itstool) path: section/p
en: To make our MessageDialog a popup attached to the main window, we set its modal property to true and set it to be "transient_for" _window. After that, we can set what kind of buttons it has and what kind of message it is (which determines what icon appears next to the message), and write out the text inside it, before connecting its "response" signal to the callback function which handles it.
cs: Aby naše dialogové okno se zprávou vyskočilo svázané s hlavním oknem, nastavíme jeho vlastnost <code>modal</code> na <code>true</code> a <code>transient_for</code> na <code>_window</code>. Po té můžeme nastavit druh tlačítek, která bude mít, a druh zprávy, kterou zobrazí (tím je dána ikona, která se objeví vedle zprávy) a napsat text zprávy. To vše před tím, než napojíme jeho signál <code>"response"</code> na funkci zpětného volání, která jej zpracuje.

note: (itstool) path: note/p
en: Here are some resources for making your own MessageDialogs:
cs: Zde je pár zdrojů, kterém můžete použít při vytváření vlastních widgetů <code>MessageDialog</code>:

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/gtk3/stable/GtkMessageDialog.html#GtkButtonsType">List of button types</link>
cs: <link href="http://developer.gnome.org/gtk3/stable/GtkMessageDialog.html#GtkButtonsType">Seznam typů tlačítek</link>

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/gtk3/stable/GtkMessageDialog.html#GtkMessageType">List of message types</link>
cs: <link href="http://developer.gnome.org/gtk3/stable/GtkMessageDialog.html#GtkMessageType">Seznam typů zpráv</link>

note: (itstool) path: section/code
en: 
        // Callback function (aka signal handler) for the response signal
        _response_cb: function (messagedialog, response_id) {
    
            // A simple switch that changes the main window's label
            switch (response_id) {
                case Gtk.ResponseType.OK:
                    this.warningLabel.set_label ("*BOOM*\n");
                    break;
                case Gtk.ResponseType.CANCEL:
                    this.warningLabel.set_label ("Good choice!\n");
                    break;
                case Gtk.ResponseType.DELETE_EVENT:
                    this.warningLabel.set_label ("Dialog closed or cancelled.\n");
                    break;
            }
    
            this._messageDialog.destroy();
    
        }
    
    });
cs: 
        // Funkce zpětného volání (neboli obsluha signálu) pro reagování na signál
        _response_cb: function (messagedialog, response_id) {
    
            // Jednoduchý rozdělovač, který mění název v záhlaví hlavního okna
            switch (response_id) {
                case Gtk.ResponseType.OK:
                    this.warningLabel.set_label ("*BOOM*\n");
                    break;
                case Gtk.ResponseType.CANCEL:
                    this.warningLabel.set_label ("Good choice!\n");
                    break;
                case Gtk.ResponseType.DELETE_EVENT:
                    this.warningLabel.set_label ("Dialog closed or cancelled.\n");
                    break;
            }
    
            this._messageDialog.destroy();
    
        }
    
    });

note: (itstool) path: section/p
en: This function takes two parameters, the MessageDialog and its response_id, both of which are automatically supplied (you don't have to manually pass them to it for it to work). Here we use a simple switch to change the "warning label"'s text, depending on which option you select. The DELETE_EVENT occurs if you press Escape to cancel the MessageDialog, instead of clicking OK or Cancel. Whatever you select, the popup is destroyed afterwards.
cs: Tato funkce má dva parametry, <code>MessageDialog</code> a jeho <code>response_id</code>, z nichž oba jsou zajištěny automaticky (nemusíte je ručně předávat, aby to fungovalo). Zde použijeme jednoduchou konstrukci <code>switch</code>, která změní text varování podle vybrané volby. Když místo kliknutí na tlačítko <gui>OK</gui> nebo <gui>Cancel</gui> zmáčknete <key>Esc</key>, nastane událost <code>DELETE_EVENT</code>. Ve všech případech dojde k likvidaci dialogového okna.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new MessageDialogExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new MessageDialogExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished MessageDialogExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci konečné třídy MessageDialogExample a aplikaci spustíme.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class MessageDialogExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsmessagedialog',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal initializes menus and builds the UI
        _onStartup() {
            this._initMenus();
            this._buildUI ();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Gtk.MessageDialog Example",
                default_height: 200,
                default_width: 400
            });
    
            // Create a silly warning message and add it to the window
            this.warningLabel = new Gtk.Label({
                label: "This application goes boom! (Not really.)"
            });
            this._window.add (this.warningLabel);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        // Build the application menu, including the button that calls the dialog
        _initMenus() {
            let menu = new Gio.Menu();
            menu.append("Message",'app.message');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            // This pops up a MessageDialog when "Message" is clicked in the menu
            let messageAction = new Gio.SimpleAction ({ name: 'message' });
            messageAction.connect('activate', () =&gt; { this._showMessageDialog(); });
            this.application.add_action(messageAction);
    
            // This closes the window when "Quit" is clicked in the menu
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
            this.application.add_action(quitAction);
        }
    
        _showMessageDialog() {
    
            // Create a modal MessageDialog whose parent is the window
            this._messageDialog = new Gtk.MessageDialog ({
                transient_for: this._window,
                modal: true,
                buttons: Gtk.ButtonsType.OK_CANCEL,
                message_type: Gtk.MessageType.WARNING,
                text: "This action will cause the universe to stop existing." });
    
            this._messageDialog.connect ('response', this._response_cb.bind(this));
            this._messageDialog.show();
        }
    
        // Callback function (aka signal handler) for the response signal
        _response_cb(messagedialog, response_id) {
    
            // A simple switch that changes the main window's label
            switch (response_id) {
                case Gtk.ResponseType.OK:
                    this.warningLabel.set_label ("*BOOM*\n");
                    break;
                case Gtk.ResponseType.CANCEL:
                    this.warningLabel.set_label ("Good choice!\n");
                    break;
                case Gtk.ResponseType.DELETE_EVENT:
                    this.warningLabel.set_label ("Dialog closed or cancelled.\n");
                    break;
            }
    
            this._messageDialog.destroy();
    
        }
    };
    
    // Run the application
    let app = new MessageDialogExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class MessageDialogExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsmessagedialog',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._initMenus();
            this._buildUI ();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Gtk.MessageDialog Example",
                default_height: 200,
                default_width: 400
            });
    
            // Vytvoří bláznivou varovnou zprávu a přidá ji do okna
            this.warningLabel = new Gtk.Label({
                label: "This application goes boom! (Not really.)"
            });
            this._window.add (this.warningLabel);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        // Sestaví aplikační nabídku, včetně položky, které volá dialogové okno
        _initMenus() {
            let menu = new Gio.Menu();
            menu.append("Message",'app.message');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            // Tímto se zobrazí MessageDialog, když je v nabídce kliknuto na Message
            let messageAction = new Gio.SimpleAction ({ name: 'message' });
            messageAction.connect('activate', () =&gt; { this._showMessageDialog(); });
            this.application.add_action(messageAction);
    
            // Tímto se zavře okno, když je v nabídce kliknuto na Quit
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
            this.application.add_action(quitAction);
        }
    
        _showMessageDialog() {
    
            // Vytvoří modální MessageDialog, jehož rodičem je okno
            this._messageDialog = new Gtk.MessageDialog ({
                transient_for: this._window,
                modal: true,
                buttons: Gtk.ButtonsType.OK_CANCEL,
                message_type: Gtk.MessageType.WARNING,
                text: "This action will cause the universe to stop existing." });
    
            this._messageDialog.connect ('response', this._response_cb.bind(this));
            this._messageDialog.show();
        }
    
        // Funkce zpětného volání (neboli obsluha signálu) pro reagování na signál
        _response_cb(messagedialog, response_id) {
    
            // Jednoduchý rozdělovač, který mění název v záhlaví hlavního okna
            switch (response_id) {
                case Gtk.ResponseType.OK:
                    this.warningLabel.set_label ("*BOOM*\n");
                    break;
                case Gtk.ResponseType.CANCEL:
                    this.warningLabel.set_label ("Good choice!\n");
                    break;
                case Gtk.ResponseType.DELETE_EVENT:
                    this.warningLabel.set_label ("Dialog closed or cancelled.\n");
                    break;
            }
    
            this._messageDialog.destroy();
    
        }
    };
    
    // Spustí aplikaci
    let app = new MessageDialogExample ();
    app.application.run (ARGV);

note: (itstool) path: page/p
en: A message dialog which prints messages on the terminal, depending on your choices.
cs: Dialogové okno se zprávou, které vypíše zprávy v závislosti na vašich volbách do terminálu.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        # constructor for a window (the parent window) with a label
        def __init__(self, app):
            Gtk.Window.__init__(self, title="GMenu Example", application=app)
            self.set_default_size(400, 200)
            label = Gtk.Label()
            label.set_text("This application goes boom!")
            self.add(label)
    
            # create the message_action (a Gio.SimpleAction) - for the window
            message_action = Gio.SimpleAction.new("message", None)
            # connect the signal from the action to the function message_cb()
            message_action.connect("activate", self.message_cb)
            # add the action to the application
            app.add_action(message_action)
    
        # callback function for the signal "activate" from the message_action
        # in the menu of the parent window
        def message_cb(self, action, parameter):
            # a Gtk.MessageDialog
            messagedialog = Gtk.MessageDialog(parent=self,
                                              flags=Gtk.DialogFlags.MODAL,
                                              type=Gtk.MessageType.WARNING,
                                              buttons=Gtk.ButtonsType.OK_CANCEL,
                                              message_format="This action will cause the universe to stop existing.")
            # connect the response (of the button clicked) to the function
            # dialog_response()
            messagedialog.connect("response", self.dialog_response)
            # show the messagedialog
            messagedialog.show()
    
        def dialog_response(self, widget, response_id):
            # if the button clicked gives response OK (-5)
            if response_id == Gtk.ResponseType.OK:
                print("*boom*")
            # if the button clicked gives response CANCEL (-6)
            elif response_id == Gtk.ResponseType.CANCEL:
                print("good choice")
            # if the messagedialog is destroyed (by pressing ESC)
            elif response_id == Gtk.ResponseType.DELETE_EVENT:
                print("dialog closed or cancelled")
            # finally, destroy the messagedialog
            widget.destroy()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def quit_cb(self, action, parameter):
            self.quit()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # create a menu (a Gio.Menu)
            menu = Gio.Menu()
            # append a menu item with label "Message" and action "app.message"
            menu.append("Message", "app.message")
            # append a menu item with label "Quit" and action "app.quit"
            menu.append("Quit", "app.quit")
            # set menu as the menu for the application
            self.set_app_menu(menu)
    
            # a new simpleaction - for the application
            quit_action = Gio.SimpleAction.new("quit", None)
            quit_action.connect("activate", self.quit_cb)
            self.add_action(quit_action)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        # Konstruktor pro okno (rodičovské okno) s popiskem
        def __init__(self, app):
            Gtk.Window.__init__(self, title="GMenu Example", application=app)
            self.set_default_size(400, 200)
            label = Gtk.Label()
            label.set_text("This application goes boom!")
            self.add(label)
    
            # Vytvoří message_action (Gio.SimpleAction) pro okno
            message_action = Gio.SimpleAction.new("message", None)
            # Napojí signál z akce na funkci message_cb()
            message_action.connect("activate", self.message_cb)
            # Přidá akci do aplikace
            app.add_action(message_action)
    
        # Funkce zpětného volání po signál "activate" z message_action
        # v nabídce rodičovského okna
        def message_cb(self, action, parameter):
            # Gtk.MessageDialog
            messagedialog = Gtk.MessageDialog(parent=self,
                                              flags=Gtk.DialogFlags.MODAL,
                                              type=Gtk.MessageType.WARNING,
                                              buttons=Gtk.ButtonsType.OK_CANCEL,
                                              message_format="This action will cause the universe to stop existing.")
            # Napojí signál "response" (od kliknutého tlačítka) na funkci
            # dialog_response()
            messagedialog.connect("response", self.dialog_response)
            # Zobrazí MessageDialog
            messagedialog.show()
    
        def dialog_response(self, widget, response_id):
            # Když je na tlačítko kliknuto, vrátí OK (-5)
            if response_id == Gtk.ResponseType.OK:
                print("*boom*")
            # Když je na tlačítko kliknuto, vrátí CANCEL (-6)
            elif response_id == Gtk.ResponseType.CANCEL:
                print("good choice")
            # Když je MessageDialog zlikvidován (zmáčknutím ESC)
            elif response_id == Gtk.ResponseType.DELETE_EVENT:
                print("dialog closed or cancelled")
            # Nakonec zlikvidujeme MessageDialog
            widget.destroy()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def quit_cb(self, action, parameter):
            self.quit()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # Vytvoří nabídku (Gio.Menu)
            menu = Gio.Menu()
            # Přidá položku nabídky s textem "Message" a akcí "app.message"
            menu.append("Message", "app.message")
            # Přidá položku nabídky s textem "Quit" a akcí "app.quit"
            menu.append("Quit", "app.quit")
            # Nastaví nabídku jako nabídku pro aplikaci
            self.set_app_menu(menu)
    
            # Nová jednoduchá akce pro aplikaci
            quit_action = Gio.SimpleAction.new("quit", None)
            quit_action.connect("activate", self.quit_cb)
            self.add_action(quit_action)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a MessageDialog widget
cs: Užitečné metody pro widget MessageDialog

note: (itstool) path: section/p
en: In line 18 the signal <code>"activate"</code> is connected to the callback function <code>message_cb()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 18 je signál <code>"activate"</code> napojen na funkci zpětného volání <code>message_cb()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: In the constructor of MessageDialog we could set flags as <code>Gtk.DialogFlags.DESTROY_WITH_PARENT</code> (to destroy the messagedialog window when its parent window is destroyed) or as <code>Gtk.DialogFlags.MODAL</code> (no interaction with other windows of the application).
cs: V konstruktoru widgetu <code>MessageDialog</code> bychom mohli nastavit příznak <code>Gtk.DialogFlags.DESTROY_WITH_PARENT</code> (pro likvidaci dialogového okna ve chvíli, kdy je zlikvidováno rodičovské okno) nebo <code>Gtk.DialogFlags.MODAL</code> (žádná komunikace uživatele s ostatními okny aplikace).

note: (itstool) path: item/p
en: In the constructor of MessageDialog we could set type as any of <code>Gtk.MessageType.INFO, Gtk.MessageType.WARNING, Gtk.MessageType.QUESTION, Gtk.MessageType.ERROR, Gtk.MessageType.OTHER</code> depending on what type of message we want.
cs: V konstruktoru widgetu <code>MessageDialog</code> bychom mohli nastavit typ na něco z <code>Gtk.MessageType.INFO</code> (informace), <code>Gtk.MessageType.WARNING</code> (varování), <code>Gtk.MessageType.QUESTION</code> (dotaz), <code>Gtk.MessageType.ERROR</code> (chybové hlášení) nebo <code>Gtk.MessageType.OTHER</code> (jiné), podle toho, jaký typ zprávy chceme.

note: (itstool) path: item/p
en: In the constructor of MessageDialog we could set buttons as any of <code>Gtk.ButtonsType.NONE, Gtk.ButtonsType.OK, Gtk.ButtonsType.CLOSE, Gtk.ButtonsType.CANCEL, Gtk.ButtonsType.YES_NO, Gtk.ButtonsType.OK_CANCEL</code>, or any button using <code>add_button()</code> as in Gtk.Dialog.
cs: V konstruktoru widgetu <code>MessageDialog</code> bychom mohli nastavit tlačítka, jako jsou standardní <code>Gtk.ButtonsType.NONE</code>, <code>Gtk.ButtonsType.OK</code>, <code>Gtk.ButtonsType.CLOSE</code>, <code>Gtk.ButtonsType.CANCEL</code>, <code>Gtk.ButtonsType.YES_NO</code>, <code>Gtk.ButtonsType.OK_CANCEL</code> nebo libovolné tlačítko pomocí <code>add_button()</code>, jako v <code>Gtk.Dialog</code>.

note: (itstool) path: item/p
en: We could substitute the default image of the MessageDialog with another image using
cs: Mohli bychom nahradit výchozí obrázek v <code>MessageDialog</code> jiným obrázkem pomocí

note: (itstool) path: item/p
en: where <code>Gtk.STOCK_CAPS_LOCK_WARNING</code> is any image from <link href="http://developer.gnome.org/gtk3/unstable/gtk3-Stock-Items.html">Stock Items</link>. We could also set any image as in the Image widget, as <code>image.set_from_file("filename.png")</code>.
cs: kde <code>Gtk.STOCK_CAPS_LOCK_WARNING</code> je jeden obrázek ze <link href="http://developer.gnome.org/gtk3/unstable/gtk3-Stock-Items.html">standardních položek</link>. Mohli bycho také nastavit libovolný obrázek podobně jako ve widgetu Image pomocí <code>image.set_from_file("název_souboru.png")</code>.

note: (itstool) path: item/p
en: <code>format_secondary_text("some secondary message")</code> sets a secondary message. The primary text becomes bold.
cs: <code>format_secondary_text("nějaká druhá zpráva")</code> nastaví druhou zprávu. Hlavní text bude tučný.

note: (itstool) path: page/code
en: 
    //A window in the application
    public class Window : Gtk.ApplicationWindow {
    	public Window (Application app) {
    		Object (application: app, title: "Gtk.MessageDialog Example");
    
    		var label = new Gtk.Label ("This application goes boom!");
    		this.add (label);
    
    		var message_action = new SimpleAction ("message", null);
    		message_action.activate.connect (message);
    		this.add_action (message_action);
    
    		this.set_default_size (400, 200);
    		this.show_all ();
    	}
    
    	void dialog_response (Gtk.Dialog dialog, int response_id) {
    		switch (response_id) {
    			case Gtk.ResponseType.OK:
    				print ("*boom*\n");
    				break;
    			case Gtk.ResponseType.CANCEL:
    				print ("good choice\n");
    				break;
    			case Gtk.ResponseType.DELETE_EVENT:
    				print ("dialog closed or cancelled\n");
    				break;
    		}
    			dialog.destroy();
    	}
    
    	void message (SimpleAction simple, Variant? parameter) {
    		var messagedialog = new Gtk.MessageDialog (this,
                                Gtk.DialogFlags.MODAL,
                                Gtk.MessageType.WARNING,
                                Gtk.ButtonsType.OK_CANCEL,
                                "This action will cause the universe to stop existing.");
    
    		messagedialog.response.connect (dialog_response);
    		messagedialog.show ();
    	}
    }
    
    //This is the Application
    public class Application : Gtk.Application {
    	protected override void activate () {
    		new Window (this);
    	}
    
    	protected override void startup () {
    		base.startup ();
    
    		var menu = new Menu ();
    		menu.append ("Message", "win.message");
    		menu.append ("Quit", "app.quit");
    		this.app_menu = menu;
    
    		var quit_action = new SimpleAction ("quit", null);
    		//quit_action.activate.connect (this.quit);
    		this.add_action (quit_action);
    	}
    
    	public Application () {
    		Object (application_id: "org.example.application");
    	}
    }
    
    //main function creates Application and runs it
    int main (string[] args) {
    	return new Application ().run (args);
    }
cs: 
    // Okno v aplikaci
    public class Window : Gtk.ApplicationWindow {
    	public Window (Application app) {
    		Object (application: app, title: "Gtk.MessageDialog Example");
    
    		var label = new Gtk.Label ("This application goes boom!");
    		this.add (label);
    
    		var message_action = new SimpleAction ("message", null);
    		message_action.activate.connect (message);
    		this.add_action (message_action);
    
    		this.set_default_size (400, 200);
    		this.show_all ();
    	}
    
    	void dialog_response (Gtk.Dialog dialog, int response_id) {
    		switch (response_id) {
    			case Gtk.ResponseType.OK:
    				print ("*boom*\n");
    				break;
    			case Gtk.ResponseType.CANCEL:
    				print ("good choice\n");
    				break;
    			case Gtk.ResponseType.DELETE_EVENT:
    				print ("dialog closed or cancelled\n");
    				break;
    		}
    			dialog.destroy();
    	}
    
    	void message (SimpleAction simple, Variant? parameter) {
    		var messagedialog = new Gtk.MessageDialog (this,
                                Gtk.DialogFlags.MODAL,
                                Gtk.MessageType.WARNING,
                                Gtk.ButtonsType.OK_CANCEL,
                                "This action will cause the universe to stop existing.");
    
    		messagedialog.response.connect (dialog_response);
    		messagedialog.show ();
    	}
    }
    
    // Toto je aplikace
    public class Application : Gtk.Application {
    	protected override void activate () {
    		new Window (this);
    	}
    
    	protected override void startup () {
    		base.startup ();
    
    		var menu = new Menu ();
    		menu.append ("Message", "win.message");
    		menu.append ("Quit", "app.quit");
    		this.app_menu = menu;
    
    		var quit_action = new SimpleAction ("quit", null);
    		//quit_action.activate.connect (this.quit);
    		this.add_action (quit_action);
    	}
    
    	public Application () {
    		Object (application_id: "org.example.application");
    	}
    }
    
    // Funkce main vytvoří aplikaci a spustí ji
    int main (string[] args) {
    	return new Application ().run (args);
    }

[ctx: text]
note: (itstool) path: info/title
en: The Model/View/Controller design (Python)
cs: Návrh typu Model/Zobrazení/Ovládání (Python)

note: (itstool) path: info/desc (itstool) path: page/title
en: The Model/View/Controller design
cs: Návrh typu Model/Zobrazení/Ovládání

note: (itstool) path: section/title
en: Overview
cs: Přehled

note: (itstool) path: section/p
en: Both the <link xref="treeview_simple_liststore.py">TreeView</link> and the <link xref="combobox.py">ComboBox</link> widgets are built on the <em>Model/View/Controller</em> design. The <em>Model</em> (an implementation of <code>Gtk.TreeModel</code>, usually <code>Gtk.TreeStore</code> or <code>Gtk.ListStore</code>) stores the data; the <em>View</em> (e.g. <code>Gtk.TreeView</code>, <code>Gtk.ComboBox</code>, or <code>Gtk.ComboBoxText</code>) gets change notifications and displays the content of the model. The <em>Controller</em>, finally, changes the state of the model (via some methods in the model's implementation - such as <code>append()</code> or <code>remove()</code>) and notifies the view of these changes (via signals like <code>"changed"</code>).
cs: Widgety <link xref="treeview_simple_liststore.py">TreeView</link> i <link xref="combobox.py">ComboBox</link> jsou postaveny na návrhu <em>Model/Zobrazení/Ovládání</em>. <em>Model</em> (implementace <code>Gtk.TreeModel</code>, obvykle <code>Gtk.TreeStore</code> nebo <code>Gtk.ListStore</code>) uchovává data, <code>Zobrazení</code> (např. <code>Gtk.TreeView</code>, <code>Gtk.ComboBox</code> nebo <code>Gtk.ComboBoxText</code>) přijímá upozornění a zobrazuje obsah modelu. A konečně <code>Ovládání</code> mění stav modelu (přes některé metody, které model implementuje, jako je <code>append()</code> nebo <code>remove()</code>) a upozorňuje zobrazení na tyto změny (pomocí signálu, jako je <code>"changed"</code>).

note: (itstool) path: section/title
en: The Model
cs: Model

note: (itstool) path: section/p
en: The main difference between the two main implementations of <code>Gtk.TreeModel</code> is that <code>Gtk.ListStore</code> contains simple rows of data without children, whereas <code>Gtk.TreeStore</code> also contains rows of data, but each row may have child rows (which in turn can have child rows, and so on).
cs: Hlavní rozdíl mezi dvěma hlavními implementacemi <code>Gtk.TreeModel</code> je, že <code>Gtk.ListStore</code> obsahuje jednoduché řádky dat bez potomků, zatímco <code>Gtk.TreeStore</code> obsahuje sice také řádky dat, ale každý řádek může mít synovské řádky (a ty také mohou mít synovské řádky a tak dále).

note: (itstool) path: section/p
en: The data in the Model can be retrieved or modified using the tree iter and column index, or <code>Gtk.TreeIter</code>, or <code>Gtk.TreePath</code>.
cs: Data v modelu mohou být získána nebo změněna pomocí stromového iterátoru a sloupcového indexu nebo metody <code>Gtk.TreeIter</code> nebo <code>Gtk.TreePath</code>.

note: (itstool) path: section/p
en: As with Python's built-in list object you can use <code>len()</code> to get the number of rows and use slices to retrieve or set values. Otherwise, the method <code>append()</code> returns a <code>Gtk.TreeIter</code> instance, which points to the location of the newly inserted row. You can also retrieve a <code>Gtk.TreeIter</code> by calling <code>get_iter()</code>.
cs: Stejně jako u objektů typu seznam vestavěných v jazyce Python, můžete použít <code>len()</code> k získání počtu řádků a „slice“ (řez) k získání nebo nastavení hodnot. Jinak metoda <code>append()</code> vrací instanci <code>Gtk.TreeIter</code>, která ukazuje na místo, kam byl nový řádek vložen. <code>Gtk.TreeIter</code> můžete získat i zavoláním <code>get_iter()</code>.

note: (itstool) path: section/p
en: As <code>Gtk.ListStore</code> contains only one level, i.e. nodes do not have any child nodes, a path is essentially the index of the row you want to access. In the case of <code>Gtk.TreeStore</code>, a path is a list of indexes or a string. The string form is a list of numbers separated by a colon. Each number refers to the offset at that level. Thus, the path <code>"0"</code> refers to the root node and the path <code>"2:4"</code> refers to the fifth child of the third node.
cs: Protože <code>Gtk.ListStore</code> obsahuje jen jednu úroveň, tj. uzly nemají žádné potomky, je cesta v podstatě jen index řádku, ke kterému chcete přístup. V případě <code>Gtk.TreeStore</code> je cesta seznam indexů nebo řetězec. Forma řetězce je seznam čísel oddělených dvojtečkami. Každé číslo odkazuje na pořadí v dané úrovni. Takže cesta <code>"0"</code> odkazuje na kořenový uzel a cesta <code>"2:4"</code> odkazuje na pátého potomka třetího uzlu.

note: (itstool) path: section/p
en: Useful methods for a <code>Gtk.TreeModel</code>:
cs: Užitečné metody pro <code>Gtk.TreeModel</code>:

note: (itstool) path: item/p
en: <code>get_iter(path)</code> returns a <code>Gtk.TreeIter</code> instance pointing to <code>path</code>. This is expected to be a colon-separated list of numbers, or a tuple. For example, the string <code>"10:4:0"</code> is equivalent to the tuple <code>(10, 4, 0)</code>, as both would create a path of depth 3 pointing to the 11th child of the root node, the 5th child of that 11th child, and the 1st child of that 5th child.
cs: <code>get_iter(cesta)</code> vrací instanci <code>Gtk.TreeIter</code> ukazující na <code>cestu</code>. Ta je očekávána v podobě seznamu čísel oddělovaného dvojtečkou nebo n-tice. Například řetězec <code>"10:4:0"</code> je stejná cesta jako n-tice <code>(10, 4, 0)</code>, protože obojí vytvoří cestu do hloubky 3. úrovně k 11. potomku od kořene, 5. pátému potomku jedenáctého potomka a 1. potomku pátého potomka.

note: (itstool) path: item/p
en: <code>iter_next(treeiter)</code> returns a <code>Gtk.TreeIter</code> instance pointing the node following treeiter at the current level or <code>None</code> if there is no next iter.
cs: <code>iter_next(stromový_iterátor)</code> vrací instanci <code>Gtk.TreeIter</code> ukazující na uzel následující za <code>stromovým_iterátorem</code> v aktuální úrovni nebo <code>None</code>, pokud tam již další není.

note: (itstool) path: item/p
en: <code>iter_has_child(treeiter)</code> returns <code>True</code> if <code>treeiter</code> has children, <code>False</code> otherwise.
cs: <code>iter_has_child(stromový_iterátor)</code> vrací <code>True</code> jestliže má <code>stromový_iterátor</code> potomky, jinak <code>False</code>.

note: (itstool) path: item/p
en: <code>iter_children(treeiter)</code> returns a <code>Gtk.TreeIter</code> instance pointing to the first child of <code>treeiter</code> or <code>None</code> if <code>treeiter</code> has no children.
cs: <code>iter_children(stromový_iterátor)</code> vrací instanci <code>Gtk.TreeIter</code> ukazující na prvního potomka <code>stromového_iterátoru</code> nebo <code>None</code>, když žádného potomka nemá.

note: (itstool) path: item/p
en: <code>get_iter_first()</code> returns a <code>Gtk.TreeIter</code> instance pointing to the first iterator in the tree (the one at the path <code>"0"</code>) or <code>None</code> if the tree is empty.
cs: <code>get_iter_first()</code> vrací instanci <code>Gtk.TreeIter</code>, která ukazuje na první iterátor ve stromu (tj. na cestě <code>"0"</code>) nebo <code>None</code>, pokud je strom prázdný.

note: (itstool) path: section/p
en: Useful methods for a <code>Gtk.ListStore</code>:
cs: Užitečné metody pro <code>Gtk.ListStore</code>:

note: (itstool) path: item/p
en: <code>append(row)</code> appends a new row to this list store, where <code>row</code> can be a list of values for each column; <code>row</code> can also be omitted or <code>None</code>, and in that case an empty row will be appended. The method returns a <code>Gtk.TreeIter</code> pointing to the appended row.
cs: <code>append(řádek)</code> připojí nový řádek do <code>ListStore</code>, kde <code>řádek</code> může být seznam hodnot pro každý ze sloupců nebo může být <code>řádek</code> vynechán či <code>None</code> a pak bude připojen prázdný řádek. Tato metoda vrací <code>Gtk.TreeIter</code> ukazující na připojený řádek.

note: (itstool) path: item/p
en: <code>remove(iter)</code> removes <code>iter</code> from the <code>Gtk.ListStore</code>, and returns <code>True</code> if the iter is valid, and <code>False</code> if the iter is not. After being removed, <code>iter</code> is set to be the next valid row.
cs: <code>remove(iterátor)</code> odstraní <code>iterátor</code> z <code>Gtk.ListStore</code> a vrátí <code>True</code> jestliže je iterátor platný nebo <code>False</code> jestliže není. Po odstranění je <code>iterátor</code> nastaven na následující platný řádek.

note: (itstool) path: section/p
en: Useful methods for a <code>Gtk.TreeStore</code>:
cs: Užitečné metody pro <code>Gtk.TreeStore</code>:

note: (itstool) path: item/p
en: <code>append(parent, row)</code> appends a new row to this tree store; <code>parent</code> must be a valid Gtk.TreeIter. If parent is not <code>None</code>, then it will append the new row after the last child of parent, otherwise it will append a row to the top level; <code>row</code> can be a list of values for each column, or it can be omitted or <code>None</code>; in this latter case an empty row will be appended. The method returns a <code>Gtk.TreeIter</code> pointing to the appended row.
cs: <code>append(rodič, řádek)</code> přidá do stromového úložiště nový řádek. Argument <code>rodič</code> musí být platný <code>Gtk.TreeIter</code>. Když rodič není <code>None</code>, bude nový řádek přidán za posledního potomka rodiče, jinak bude přidán do nejvyšší úrovně. Argument <code>řádek</code> může být seznam hodnot pro jednotlivé sloupce nebo může být vynechán nebo <code>None</code>. V posledních dvou zmíněných případech bude připojen prázdný řádek. Metoda vrací <code>Gtk.TreeIter</code> ukazující na připojený řádek.

note: (itstool) path: section/title
en: The View: the TreeView case
cs: Zobrazení: případ TreeView

note: (itstool) path: section/p
en: A Treeview shows the structure of children and parent items as a tree. See for instance <link xref="treeview_treestore.py">this example</link>.
cs: <code>TreeView</code> zobrazuje strukturu dceřiných a rodičovských položek v podobě stromu. Viz třeba <link xref="treeview_treestore.py">tento příklad</link>.

note: (itstool) path: section/p
en: The <code>Gtk.TreeViewColumn</code> is used to organize the vertical columns.
cs: <code>Gtk.TreeViewColumn</code> je použito k uspořádání svislých sloupců.

note: (itstool) path: section/p
en: Useful methods for a <code>Gtk.TreeView</code>:
cs: Užitečné metody pro <code>Gtk.TreeView</code>:

note: (itstool) path: item/p
en: <code>set_model(model)</code> sets the model for this tree view. If this tree view already has a model set, it will remove it before setting the new model. If model is <code>None</code>, then it will unset the old model.
cs: <code>set_model(model)</code> nastaví model pro toto stromové zobrazení. Pokud již nějaký model nastavené má, tak ten bude nejdříve odebrán. Jestliže je model <code>None</code>, tak se zruší nastavení starého modelu.

note: (itstool) path: item/p
en: <code>get_model()</code> returns the model this tree view is based on, <code>None</code> if the model is unset.
cs: <code>get_model()</code> vrací model, na kterém je strom založen, <code>None</code>, když model není nastaven.

note: (itstool) path: item/p
en: <code>append_column(column)</code> appends <code>column</code> to the list of columns.
cs: <code>append_column(sloupec)</code> připojí <code>sloupec</code> do seznamu sloupců.

note: (itstool) path: item/p
en: <code>get_selection()</code> gets the <code>Gtk.TreeSelection</code> associated with this tree view.
cs: <code>get_selection()</code> vrací <code>Gtk.TreeSelection</code> přidružené k tomuto stromovému zobrazení.

note: (itstool) path: section/p
en: Useful methods for a <code>Gtk.TreeViewColumn</code>:
cs: Užitečné metody pro <code>Gtk.TreeViewColumn</code>:

note: (itstool) path: item/p
en: <code>add_attribute(renderer, attribute, value)</code> adds an attribute mapping to this column. <code>attribute</code> is the parameter on <code>renderer</code> to be set from the <code>value</code>
cs: <code>add_attribute(vykreslovač, atribut, hodnota)</code> přidá mapování atributu na tento sloupec. <code>atribut</code> je parametr <code>vykreslovače</code>, který má být nastaven na <code>hodnotu</code>.

note: (itstool) path: item/p
en: <code>pack_start(renderer, expand)</code> packs <code>renderer</code> into the beginning of this column. If <code>expand</code> is <code>False</code>, then <code>renderer</code> is allocated no more space than it needs. Any unused space is divided evenly between cells for which expand is <code>True</code>.
cs: <code>pack_start(vykreslovač, roztáhnout)</code> zabalí <code>vykreslovač</code> do začátku tohoto sloupce. Když je <code>roztáhnout</code> nastaveno na <code>False</code>, nebude si <code>vykreslovač</code> nárokovat víc místa, než potřebuje. Veškeré nevyužité místo je rovnoměrně rozděleno mezi buňky, kterém mají tento parametr nastavený na <code>True</code>.

note: (itstool) path: item/p
en: <code>pack_end(renderer, expand)</code> adds <code>renderer</code> to end of this column. If <code>expand</code> is <code>False</code>, then <code>renderer</code> is allocated no more space than it needs. Any unused space is divided evenly between cells for which <code>expand</code> is <code>True</code>.
cs: <code>pack_end(vykreslovač, roztáhnout)</code> zabalí <code>vykreslovač</code> do konce tohoto sloupce. Když je <code>roztáhnout</code> nastaveno na <code>False</code>, nebude si <code>vykreslovač</code> nárokovat víc místa, než potřebuje. Veškeré nevyužité místo je rovnoměrně rozděleno mezi buňky, kterém mají tento parametr nastavený na <code>True</code>.

note: (itstool) path: item/p
en: <code>set_sort_column_id(sort_column_id)</code> sets the column of the model by which this column (of the view) should be sorted. This also makes the column header clickable.
cs: <code>set_sort_column_id(id_slupce_řazení)</code> nastaví sloupec z modelu, podle kterého by se měl tento sloupec (v zobrazení) řadit. Rovněž to zpřístupní záhlaví sloupce pro kliknutí.

note: (itstool) path: item/p
en: <code>set_sort_indicator(setting)</code> sets whether a little arrow is displayed in the column header; <code>setting</code> can either be <code>True</code> (indicator is shown) or <code>False</code>.
cs: <code>set_sort_indicator(nastavení)</code> nastaví, jestli se má v záhlaví sloupce zobrazovat malá šipka. Argument <code>nastavení</code> může být <code>True</code> (indikátor je zobrazen) nebo <code>False</code>.

note: (itstool) path: item/p
en: <code>set_sort_order(order)</code> changes the order by which the column is sorted; <code>order</code> can either be <code>Gtk.SortType.ASCENDING</code> or <code>Gtk.SortType.DESCENDING</code>.
cs: <code>set_sort_order(pořadí)</code> změní pořadí, ve kterém je sloupec seřazen. <code>pořadí</code> může být <code>Gtk.SortType.ASCENDING</code> (vzestupné) nebo <code>Gtk.SortType.DESCENDING</code> (sestupné).

note: (itstool) path: section/title
en: The View: the ComboBox case
cs: Zobrazení: případ ComboBox

note: (itstool) path: section/p
en: A <code>Gtk.ComboBox</code> allows for the selection of an item from a dropdown menu, see for instance <link xref="combobox.py">this example</link>. For a list of textual choices, one can also use the simpler <code>Gtk.ComboBoxText</code>. Both <code>Gtk.ComboBox</code> and <code>Gtk.ComboBoxText</code> can contain an entry.
cs: <code>Gtk.ComboBox</code> poskytuje výběr z položek v rozbalovací nabídce, viz třeba <link xref="combobox.py">tento příklad</link>. Pro seznam s čistě textovými položkami lze použít také jednodušší <code>Gtk.ComboBoxText</code>. Obě verze mohou obsahovat vstupní pole.

note: (itstool) path: section/p
en: Useful methods for a <code>Gtk.ComboBox</code>:
cs: Užitečné metody pro <code>Gtk.ComboBox</code>:

note: (itstool) path: item/p
en: The static method <code>new_with_entry()</code> creates a new empty <code>Gtk.ComboBox</code> with an entry; the static method <code>new_with_model(model)</code> creates a new one with the model initialized to <code>model</code>; and the static method <code>new_with_model_and_entry(model)</code> is a combination of the two.
cs: Statická metoda <code>new_with_entry()</code> vytvoří nový prázdný <code>Gtk.ComboBox</code> se vstupním polem. Statická metoda <code>new_with_model(model)</code> jej vytvoří s modelem inicializovaným na <code>model</code>. A statická metodat <code>new_with_model_and_entry(model)</code> je kombinací dvou předchozích.

note: (itstool) path: item/p
en: <code>get_active_iter()</code> returns a <code>Gtk.TreeIter</code> pointing to the current active item. If no active item exists, <code>None</code> is returned.
cs: <code>get_active_iter()</code> vrací <code>Gtk.TreeIter</code> ukazující na právě aktivní položku. Pokud žádná aktivní položka neexistuje, je vráceno <code>None</code>.

note: (itstool) path: item/p
en: <code>set_model(model)</code> sets the model used by this combo box to be <code>model</code>, and it will unset a previously set model (if there is any). If <code>model</code> is <code>None</code>, then it will unset the model. Note that this function does not clear the cell renderers.
cs: <code>set_model(model)</code> nastaví model použitý tímto rozbalovacím seznamem na <code>model</code> a zruší nastavení předchozího nastaveného modelu (pokud nějaký byl). Pokud je <code>model</code> <code>None</code>, bude jen zrušeno nastavení předchozího. Upozorňujeme, že tato funkce nemaže vykreslovače buněk.

note: (itstool) path: item/p
en: <code>set_entry_text_column(text_column)</code> sets the model column which this combo box should use to get strings from to be <code>text_column</code>. The column <code>text_column</code> in the model of this combo box must be of type <code>str</code> (this is only relevant if this combo box has been created with the “has-entry” property set to True).
cs: <code>set_entry_text_column(textový_sloupec)</code> nastavuje sloupec modelu, který by měl tento rozbalovací seznam použít k získávání řetězců, na <code>textový_sloupec</code>. Tento sloupec musí být typu <code>str</code> (to platí v případě, že rozbalovací seznam byl vytvořen s vlastností <code>"has-entry"</code> nastavenou na <code>True</code>).

note: (itstool) path: item/p
en: <code>set_wrap_width(width)</code> sets the wrap width of this combo box to be <code>width</code>. The wrap width is basically the preferred number of columns when you want the popup to be laid out in a grid.
cs: <code>set_wrap_width(šířka)</code> nastavuje šířku zalamování rozbalovacího seznamu na <code>šířka</code>. Jedná se v zásadě o upřednostňovaný počet sloupců, když chcete, aby byl rozbalený seznam rozvržen do mřížky.

note: (itstool) path: section/p
en: Useful methods for a <code>Gtk.ComboBoxText</code>:
cs: Užitečné metody pro <code>Gtk.ComboBoxText</code>:

note: (itstool) path: item/p
en: The static method <code>new_with_entry()</code> creates a new empty <code>Gtk.ComboBoxText</code> with an entry.
cs: Statická metoda <code>new_with_entry()</code> vytvoří nový prázdný <code>Gtk.ComboBoxText</code> se vstupním polem.

note: (itstool) path: item/p
en: <code>append_text(text)</code> appends <code>text</code> to the list of strings stored in this combo box.
cs: <code>append_text(text)</code> připojí <code>text</code> do seznamu řetězců uchovaných v tomto rozbalovacím seznamu.

note: (itstool) path: item/p
en: <code>get_active_text()</code> returns the currently active string in this combo box, or <code>None</code> if none is selected. If this combo box contains an entry, this function will return its contents (which will not necessarily be an item from the list).
cs: <code>get_active_text()</code> vrací aktuálně aktivní řetězec v rozbalovacím seznamu nebo <code>None</code>, když není nic vybráno. V případě, kdy má rozbalovací seznam vstupní pole, vrací tato funkce obsah tohoto pole (což nutně nemusí být žádná položka ze seznamu).

note: (itstool) path: section/title
en: The View: the Cellrenderers
cs: Zobrazení: vykreslování buněk

note: (itstool) path: section/p
en: The View makes use of <code>Gtk.CellRenderer</code>s of various types to draw the data.
cs: K vykreslení různých typů dat používá <code>View</code> objekty <code>Gtk.CellRenderer</code>.

note: (itstool) path: section/p
en: Implementations of <code>Gtk.CellRenderer</code> and useful methods:
cs: Implementace <code>Gtk.CellRenderer</code> a užitečných metod:

note: (itstool) path: item/p
en: <code>Gtk.CellRendererText</code> - renders text in a cell
cs: <code>Gtk.CellRendererText</code> – vykresluje text v buňce.

note: (itstool) path: item/p
en: <code>Gtk.CellRendererToggle</code> - renders a toggle or radio button in a cell. Useful methods:
cs: <code>Gtk.CellRendererToggle</code> – vykresluje v buňce přepínací tlačítko nebo skupinový přepínač. Užitečné metody:

note: (itstool) path: item/p
en: <code>set_active(setting)</code> - activates or deactivates a cell renderer
cs: <code>set_active(nastavení)</code> – aktivuje nebo deaktivuje vykreslování buňky

note: (itstool) path: item/p
en: <code>get_active()</code> - returns whether the cell renderer is active
cs: <code>get_active()</code> – vrací, jestli je vykreslování buňky aktivní

note: (itstool) path: item/p
en: <code>set_radio(radio)</code> - if radio is <code>True</code>, the cell renderer renders a radio toggle (i.e. a toggle in a group of mutually-exclusive toggles); if <code>False</code>, it renders a check toggle (a standalone boolean option)
cs: <code>set_radio(skupinový_přepínač)</code> – pokud je <code>skupinový_přepínač</code> <code>True</code>, bude vykreslovač buňky vykreslovat skupinový přepínač (tj. navzájem se vylučující přepínače), pokud je <code>False</code>, bude se vykreslovat zaškrtávací políčko (samostatná volba)

note: (itstool) path: item/p
en: <code>get_radio()</code> - returns whether we are rendering radio toggles rather than checkboxes.
cs: <code>get_radio()</code> – vrací, jestli vykreslujeme skupinové přepínače místo zaškrtávacích políček.

note: (itstool) path: item/p
en: <code>Gtk.CellRendererPixbuf</code> - renders an image in a cell
cs: <code>Gtk.CellRendererPixbuf</code> – vykresluje obrázek v buňce

note: (itstool) path: item/p
en: <code>Gtk.CellRendererCombo</code> - renders text in a cell; but while <code>Gtk.CellRendererText</code> offers a simple entry to edit the text, <code>Gtk.CellRendererCombo</code> offers a <code>Gtk.ComboBox</code> widget to edit the text. It can be used with and without an associated Gtk.Entry widget, depending on the value of the “has-entry” property.
cs: <code>Gtk.CellRendererCombo</code>  – vykresluje v buňce text; ale zatímco <code>Gtk.CellRendererText</code> poskytuje jednoduché vstupní pole pro úpravu textu, <code>Gtk.CellRendererCombo</code> poskytuje pro úpravu textu widget <code>Gtk.ComboBox</code>. Ten lze použít s nebo bez přidruženého widgetu <code>Gtk.Entry</code>, v závislosti na vlastnosti <code>"has-entry"</code>.

note: (itstool) path: item/p
en: <code>Gtk.CellRendererProgress</code> - renders a numeric value as a progress bar in a cell; it can display a text on top of the progress bar
cs: <code>Gtk.CellRendererProgress</code> – vykresluje v buňce číselnou hodnotu v podobě ukazatele průběhu; nad ukazatelem může zobrazit text

note: (itstool) path: item/p
en: <code>Gtk.CellRendererSpinner</code> - renders a spinning animation in a cell
cs: <code>Gtk.CellRendererSpinner</code> – vykresluje v buňce animovanou káču

note: (itstool) path: item/p
en: <code>Gtk.CellRendererSpin</code> - renders a spin button in a cell
cs: <code>Gtk.CellRendererSpin</code> – vykresluje v buňce číselník

note: (itstool) path: item/p
en: <code>Gtk.CellRendererAccel</code> - renders a keyboard accelerator in a cell
cs: <code>Gtk.CellRendererAccel</code> – vykresluje v buňce klávesovou zkratku

note: (itstool) path: section/title
en: The Controller: the Selection
cs: Ovládání: výběr

note: (itstool) path: section/p
en: Most applications will need to not only deal with displaying data, but also receiving input events from users. To do this, simply get a reference to a selection object and connect to the <code>"changed"</code> signal.
cs: Většina aplikací potřebuje používat nejen zobrazení dat, ale i přijímat vstupní události od uživatelů. To udělají jednoduše tak, že získají odkaz na objekt s výběrem a napojí se na signál <code>"changed"</code>.

note: (itstool) path: section/p
en: Then to retrieve data for the row selected:
cs: Pak k získání dat pro vybraný řádek:

note: (itstool) path: section/p
en: Useful methods for a <code>Gtk.TreeSelection</code>:
cs: Užitečné metody pro <code>Gtk.TreeSelection</code>:

note: (itstool) path: item/p
en: <code>set_mode(type)</code> sets the type of selection, where type is one of
cs: <code>set_mode(typ)</code> nastaví typ výběru, kde typ může být něco z

note: (itstool) path: item/p
en: <code>Gtk.SelectionMode.NONE</code> - no selection is possible
cs: <code>Gtk.SelectionMode.NONE</code> – není možný žádný výběr

note: (itstool) path: item/p
en: <code>Gtk.SelectionMode.SINGLE</code> - zero or one element may be selected
cs: <code>Gtk.SelectionMode.SINGLE</code> – může být vybrán žádný nebo jeden prvek

note: (itstool) path: item/p
en: <code>Gtk.SelectionMode.BROWSE</code> - exactly one element is selected. In some circumstances, such as initially or during a search operation, it’s possible for no element to be selected. What is really enforced is that the user can’t deselect a currently selected element except by selecting another element.
cs: <code>Gtk.SelectionMode.BROWSE</code> – je vybrán právě jeden prvek. V některých případech, jako na počátku nebo v průběhu vyhledávání, je možné, aby nebyl vybrán žádný prvek. To, co je opravdu vynucováno, je, že uživatel nemůže zrušit výběr aktuálně vybraného prvku, jedině může vybrat jiný.

note: (itstool) path: item/p
en: <code>Gtk.SelectionMode.MULTIPLE</code> -any number of elements may be selected. Clicks toggle the state of an item. The Ctrl key may be used to enlarge the selection, and Shift key to select between the focus and the child pointed to. Some widgets may also allow Click-drag to select a range of elements.
cs: <code>Gtk.SelectionMode.MULTIPLE</code> – může být vybrán libovolný počet prvků. Kliknutí přepne stav položky. Klávesu <key>Ctrl</key> lze používat k přidávání výběru a klávesu <key>Shift</key> k výběru rozsahu mezi zaměřenou a kliknutou položkou. Některé widgety mohou umožňovat výběr rozsahu prvků i postupem „klikni a táhni“.

note: (itstool) path: item/p
en: <code>get_selected()</code> returns a tuple <code>(model, treeiter)</code>, where <code>model</code> is the current model and <code>treeiter</code> a <code>Gtk.TreeIter</code> pointing to the currently selected row, or None if no rows are selected. The method does not work if the selection mode is set to <code>Gtk.SelectionMode.MULTIPLE</code>; in that case, use <code>get_selected_rows()</code> instead, which Returns a list of <code>Gtk.TreePath</code> instances of all selected rows.
cs: <code>get_selected()</code> vrací dvojici <code>(model, stromový_iterátor)</code>, kde <code>model</code> je aktuální model a <code>stromový_iterátor</code> je <code>Gtk.TreeIter</code> ukazující na aktuálně vybraný řádek nebo <code>None</code>, když není žádný řádek vybrán. Metoda nepracuje, když je režim výběru nastaven na <code>Gtk.SelectionMode.MULTIPLE</code>. V tomto případě použijte místo toho <code>get_selected_rows()</code>, která vrací seznam instancí <code>Gtk.TreePath</code> se všemi vybranými řádky.

note: (itstool) path: section/title
en: References
cs: Odkazy

note: (itstool) path: info/desc
en: A widget with two adjustable panes
cs: Widget se dvěma přizpůsobitelnými panely

note: (itstool) path: page/p
en: Two images in two adjustable panes, horizontally aligned.
cs: Dva obrázky ve dvou přizpůsobitelných panelech, vyrovnaných vodorovně.

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/gtk3/stable/gtk3-Standard-Enumerations.html#GtkOrientation">Standard Enumerations</link>
cs: <link href="http://developer.gnome.org/gtk3/stable/gtk3-Standard-Enumerations.html#GtkOrientation">Standardní výčty</link>

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    class PanedExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({ application_id: 'org.example.panedexample' });
    
           // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this.window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
            // Create the application window
            this.window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                        window_position: Gtk.WindowPosition.CENTER,
                                                        title: "Paned Window Example",
                                                        default_width: 450,
                                                        default_height: 350,
                                                        border_width: 10 });
    
            // a new widget with two adjustable panes,
            // one on the left and one on the right
            this.paned = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL);
    
            // two images
            this.image1 = new Gtk.Image();
            this.image1.set_from_file("gnome-image.png");
            this.image2 = new Gtk.Image();
            this.image2.set_from_file("tux.png");
    
            // add the first image to the left pane
            this.paned.add1(this.image1);
            // add the second image to the right pane
            this.paned.add2(this.image2)
    
            // add the panes to the window
            this.window.add(this.paned)
            this.window.show_all();
        }
    };
    
    // Run the application
    let app = new PanedExample();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    class PanedExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({ application_id: 'org.example.panedexample' });
    
           // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this.window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
            // Vytvoří okno aplikace
            this.window = new Gtk.ApplicationWindow  ({ application: this.application,
                                                        window_position: Gtk.WindowPosition.CENTER,
                                                        title: "Paned Window Example",
                                                        default_width: 450,
                                                        default_height: 350,
                                                        border_width: 10 });
    
            // Nový widget se dvěma přizpůsobitelnými panely,
            // jedním vlevo a jedním vpravo
            this.paned = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL);
    
            // Dva obrázky
            this.image1 = new Gtk.Image();
            this.image1.set_from_file("gnome-image.png");
            this.image2 = new Gtk.Image();
            this.image2.set_from_file("tux.png");
    
            // Přidá první obrázek do levého panelu
            this.paned.add1(this.image1);
            // Přidá druhý obrázek do pravého panelu
            this.paned.add2(this.image2)
    
            // Přidá panely do okna
            this.window.add(this.paned)
            this.window.show_all();
        }
    };
    
    // Spustí aplikaci
    let app = new PanedExample();
    app.application.run (ARGV);

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Paned Example", application=app)
            self.set_default_size(450, 350)
    
            # a new widget with two adjustable panes,
            # one on the left and one on the right
            paned = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL)
    
            # two images
            image1 = Gtk.Image()
            image1.set_from_file("gnome-image.png")
            image2 = Gtk.Image()
            image2.set_from_file("tux.png")
    
            # add the first image to the left pane
            paned.add1(image1)
            # add the second image to the right pane
            paned.add2(image2)
    
            # add the panes to the window
            self.add(paned)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Paned Example", application=app)
            self.set_default_size(450, 350)
    
            # Nový widget se dvěma přizpůsobitelnými panely,
            # jedním nalevo a jedním napravo
            paned = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL)
    
            # Dva obrázky
            image1 = Gtk.Image()
            image1.set_from_file("gnome-image.png")
            image2 = Gtk.Image()
            image2.set_from_file("tux.png")
    
            # Přidá první obrázek do panelu vlevo
            paned.add1(image1)
            # Přidá druhý obrázek do panelu vpravo
            paned.add2(image2)
    
            # Přidá panely do okna
            self.add(paned)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Paned widget
cs: Užitečné metody pro widget Paned

note: (itstool) path: section/p
en: To have two vertically aligned panes, use <code>Gtk.Orientation.VERTICAL</code> instead of <code>Gtk.Orientation.HORIZONTAL</code>. The method <code>add1(widget1)</code> will add the <code>widget1</code> to the top pane, and <code>add2(widget2)</code> will add the <code>widget2</code> to the bottom pane.
cs: Abyste získali dva svisle vyrovnané panely, použijte <code>Gtk.Orientation.VERTICAL</code> namísto <code>Gtk.Orientation.HORIZONTAL</code>. Metoda <code>add1(widget1)</code> přidá <code>widget1</code> do horního panelu a <code>add2(widget2)</code> přidá <code>widget2</code> do spodního panelu.

note: (itstool) path: section/code
en: /* This is the application. */
    public class MyApplication : Gtk.Application {
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "Paned Example";
    		window.set_default_size (450,350);
    
    		// a new widget with two adjustable panes,
    		// one on the left and one on the right
    		var paned = new Gtk.Paned (Gtk.Orientation.HORIZONTAL);
    
    		/* two images */
    		var image1 = new Gtk.Image ();
    		image1.set_from_file ("gnome-image.png");
    		var image2 = new Gtk.Image ();
    		image2.set_from_file ("tux.png");
    
    		/* add the first image to the left pane */
    		paned.add1 (image1);
    
    		/* add the second image to the right pane */
    		paned.add2 (image2);
    
    		/* add the panes to the window */
    		window.add (paned);
    		window.show_all ();
    	}
    }
    
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Toto je aplikace. */
    public class MyApplication : Gtk.Application {
    	/* Přepíše signál "activate" z GLib.Application. */
    	protected override void activate () {
    
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "Paned Example";
    		window.set_default_size (450,350);
    
    		// Nový widget se dvěma přizpůsobitelnými panely,
    		// jedním nalevo a druhým napravo
    		var paned = new Gtk.Paned (Gtk.Orientation.HORIZONTAL);
    
    		/* Dva obrázky */
    		var image1 = new Gtk.Image ();
    		image1.set_from_file ("gnome-image.png");
    		var image2 = new Gtk.Image ();
    		image2.set_from_file ("tux.png");
    
    		/* Přidá první obrázek do levého panelu */
    		paned.add1 (image1);
    
    		/* Přidá druhý obrázek do pravého panelu */
    		paned.add2 (image2);
    
    		/* Přidá panely do okna */
    		window.add (paned);
    		window.show_all ();
    	}
    }
    
    /* main vytvoří a spustí aplikaci. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

[ctx: text]
note: (itstool) path: info/title
en: Photo wall (C)
cs: Fotostěna (C)

note: (itstool) path: info/desc
en: A Clutter image viewer
cs: Prohlížeč obrázků používající Clutter.

note: (itstool) path: page/title
en: Photo wall
cs: Fotostěna

note: (itstool) path: synopsis/p
en: For this example we will build a simple image viewer using Clutter. You will learn:
cs: Pro tento příklad vytvoříme jednoduchý prohlížeč obrázků používající Clutter. Naučíte se:

note: (itstool) path: item/p
en: How to size and position <code>ClutterActor</code>s
cs: jak nastavit velikost a pozici objektů <code>ClutterActor</code>

note: (itstool) path: item/p
en: How to place an image in a <code>ClutterActor</code>
cs: jak umístit obrázek do objektu <code>ClutterActor</code>

note: (itstool) path: item/p
en: How to do simple transitions using Clutter's animation framework
cs: jak udělat jednoduché přechody pomocí základní animační konstrukce Clutter

note: (itstool) path: item/p
en: How to make <code>ClutterActor</code>s respond to mouse events
cs: jak přimět objekty <code>ClutterActor</code> reagovat na události myši

note: (itstool) path: item/p
en: How to get file names from a directory
cs: jak získat názvy souborů ze složky

note: (itstool) path: section/title
en: Introduction
cs: Úvod

note: (itstool) path: section/p
en: Clutter is a library for creating dynamic user interfaces using OpenGL for hardware acceleration. This example demonstrates a small, but central, part of the Clutter library to create a simple but attractive image viewing program.
cs: Clutter je knihovna sloužící k vytváření dynamického uživatelského rozhraní pomocí OpenGL s podporou hardwarové akcelerace. Tento příklad předvádí malou, ale podstatnou část knihovny Clutter na vytvoření jednoduchého, ale atraktivního programu k prohlížení obrázků.

note: (itstool) path: section/p
en: 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>GPtrArray</code>, a dynamic array of pointers, to hold the 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.
cs: Abychom dosáhli našeho cíle, využijeme také pár dalších částí GLib. Nejpodstatnější je použití <code>GPtrArray</code>, což je dynamické pole ukazatelů, pro uchování názvů cest. Dále použijeme <code>GDir</code>, což je pomůcka pro práci se složkami, k přístupu k našim složkám s obrázky a ke shromáždění cest k souborům.

note: (itstool) path: item/p
en: Choose <gui>GTK+ (simple)</gui> from the <gui>C</gui> tab, click <gui>Continue</gui>, and fill out your details on the next few pages. Use <file>photo-wall</file> as project name and directory.
cs: Na kartě <gui>C</gui> zvolte <gui>GTK+ (jednoduchý)</gui>, klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>photo-wall</file>.

note: (itstool) path: item/p
en: Make sure that <gui>Use GtkBuilder for user interface</gui> is disabled as we will create the UI manually in this tutorial. Check the <link xref="guitar-tuner.c">Guitar-Tuner</link> tutorial using the interface builder.
cs: Ujistěte se, že <gui>Použít GtkBuilder k tvorbě uživatelského rozhraní</gui> je vypnuto, protože jej chceme v této lekci vytvořit ručně. Na použití návrháře uživatelského rozhraní se podívejte do lekce <link xref="guitar-tuner.c">Kytarová ladička</link>.

note: (itstool) path: item/p
en: Enable <gui>Configure external packages</gui>. On the next page, select <em>clutter-1.0</em> from the list to include the Clutter library in your project.
cs: Zapněte <gui>Konfigurovat externí balíčky</gui>. Na následující stránce vyberte v seznamu <em>clutter-1.0</em>, aby se knihovna Clutter zahrnula do vašeho projektu.

note: (itstool) path: section/title
en: A look at Photo Wall
cs: Pohled na fotostěnu

note: (itstool) path: section/p
en: Our image viewer presents the user with a wall of images.
cs: Náš prohlížeč obrázků zobrazuje uživateli stěnu plnou obrázků.

note: (itstool) path: section/p
en: When an image is clicked, it is animated to fill the viewing area. When the image having focus is clicked it is returned to its original position using an animation with the same duration of 500 milliseconds.
cs: Když se na obrázek klikne, je animován s cílem vyplnit prohlížecí oblast. Když se na zaměřený obrázek klikne, vrátí se na své původní místo, opět pomocí animace. Obě animace trvají 500 milisekund.

note: (itstool) path: section/title
en: Initial setup
cs: Počáteční nastavení

note: (itstool) path: section/p
en: The following code segment contains many of the defines and variables we will be using in the following sections. Use this as a reference for later sections. Copy this code to the beginning of <file>src/main.c</file>:
cs: Následující úseku kódu obsahuje řadu definic a proměnných, které budeme používat v následujících částech. Použijte to jako vodítko pro následující části. Zkopírujte tento kód na začátek <file>src/main.c</file>:

note: (itstool) path: section/title
en: Jumping into the code
cs: Vzhůru do kódu

note: (itstool) path: section/p
en: We will start by taking a look at the <code>main()</code> function as a whole. Then we'll discuss the other code sections in detail. Change the <file>src/main.c</file> to contain this <code>main()</code> function. You can delete the <code>create_window()</code> function as we don't need it in this example.
cs: Začneme tím, že se podíváme na celou funkci <code>main()</code>. Pak rozebereme podrobně další části kódu. Změňte <file>src/main.c</file>, aby obsahoval tuto funkci <code>main()</code>. Funkci <code>create_window()</code> můžete smazat, protože ji v tomto příkladu nebudeme potřebovat.

note: (itstool) path: section/code
en: 
    int
    main(int argc, char *argv[])
    {
        ClutterColor stage_color = { 16, 16, 16, 255 };
        ClutterActor *stage = NULL;
    
        if (clutter_init (&amp;argc, &amp;argv) != CLUTTER_INIT_SUCCESS)
            return 1;
    
        stage = clutter_stage_new();
        clutter_actor_set_size(stage, STAGE_WIDTH, STAGE_HEIGHT);
        clutter_actor_set_background_color(stage, &amp;stage_color);
        clutter_stage_set_title(CLUTTER_STAGE (stage), "Photo Wall");
        g_signal_connect(stage, "destroy", G_CALLBACK(clutter_main_quit), NULL);
    
        load_image_path_names();
    
        guint row = 0;
        guint col = 0;
        for(row=0; row &lt; ROW_COUNT; ++row)
        {
            for(col=0; col &lt; COL_COUNT; ++col)
            {
                const char *img_path = g_ptr_array_index(img_paths, (row * COL_COUNT) + col);
                GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file_at_size(img_path, STAGE_HEIGHT, STAGE_HEIGHT, NULL);
                ClutterContent *image = clutter_image_new ();
                ClutterActor *actor = clutter_actor_new ();
    
                if (pixbuf != NULL)
                {
                    clutter_image_set_data(CLUTTER_IMAGE(image),
                                           gdk_pixbuf_get_pixels(pixbuf),
                                           gdk_pixbuf_get_has_alpha(pixbuf)
                                               ? COGL_PIXEL_FORMAT_RGBA_8888
                                               : COGL_PIXEL_FORMAT_RGB_888,
                                           gdk_pixbuf_get_width(pixbuf),
                                           gdk_pixbuf_get_height(pixbuf),
                                           gdk_pixbuf_get_rowstride(pixbuf),
                                           NULL);
                }
    
                clutter_actor_set_content(actor, image);
                g_object_unref(image);
                g_object_unref(pixbuf);
    
                initialize_actor(actor, row, col);
                clutter_actor_add_child(stage, actor);
            }
        }
    
        /* Show the stage. */
        clutter_actor_show(stage);
    
        /* Start the clutter main loop. */
        clutter_main();
    
        g_ptr_array_unref(img_paths);
    
        return 0;
    }
cs: 
    int
    main(int argc, char *argv[])
    {
        ClutterColor stage_color = { 16, 16, 16, 255 };
        ClutterActor *stage = NULL;
    
        if (clutter_init (&amp;argc, &amp;argv) != CLUTTER_INIT_SUCCESS)
            return 1;
    
        stage = clutter_stage_new();
        clutter_actor_set_size(stage, STAGE_WIDTH, STAGE_HEIGHT);
        clutter_actor_set_background_color(stage, &amp;stage_color);
        clutter_stage_set_title(CLUTTER_STAGE (stage), "Photo Wall");
        g_signal_connect(stage, "destroy", G_CALLBACK(clutter_main_quit), NULL);
    
        load_image_path_names();
    
        guint row = 0;
        guint col = 0;
        for(row=0; row &lt; ROW_COUNT; ++row)
        {
            for(col=0; col &lt; COL_COUNT; ++col)
            {
                const char *img_path = g_ptr_array_index(img_paths, (row * COL_COUNT) + col);
                GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file_at_size(img_path, STAGE_HEIGHT, STAGE_HEIGHT, NULL);
                ClutterContent *image = clutter_image_new ();
                ClutterActor *actor = clutter_actor_new ();
    
                if (pixbuf != NULL)
                {
                    clutter_image_set_data(CLUTTER_IMAGE(image),
                                           gdk_pixbuf_get_pixels(pixbuf),
                                           gdk_pixbuf_get_has_alpha(pixbuf)
                                               ? COGL_PIXEL_FORMAT_RGBA_8888
                                               : COGL_PIXEL_FORMAT_RGB_888,
                                           gdk_pixbuf_get_width(pixbuf),
                                           gdk_pixbuf_get_height(pixbuf),
                                           gdk_pixbuf_get_rowstride(pixbuf),
                                           NULL);
                }
    
                clutter_actor_set_content(actor, image);
                g_object_unref(image);
                g_object_unref(pixbuf);
    
                initialize_actor(actor, row, col);
                clutter_actor_add_child(stage, actor);
            }
        }
    
        /* Zobrazí scénu */
        clutter_actor_show(stage);
    
        /* Spustí hlavní smyčku clutter */
        clutter_main();
    
        g_ptr_array_unref(img_paths);
    
        return 0;
    }

note: (itstool) path: item/p
en: Line 4: <code>ClutterColor</code> is defined by setting the red, green, blue and transparency (alpha) values. The values range from 0-255. For transparency a value of 255 is opaque.
cs: Řádek 4: Je definován <code>ClutterColor</code> nastavením hodnot červené, zelené, modré a průhledné (alfa). Hodnoty jsou z rozsahu 0 až 255. Pro průhlednou složku znamená 255 plné krytí.

note: (itstool) path: item/p
en: Line 7: You must initialize Clutter. If you forget to do this, you will get very strange errors. Be warned.
cs: Řádek 7: Musíte inicializovat Clutter. Pokud na to zapomenete, obdržíte velmi podivné chyby. Dávejte si na to pozor.

note: (itstool) path: item/p
en: Lines 10‒14: Here we create a new <code>ClutterStage</code> . We then set the size using the defines from the previous section and the address of the <code>ClutterColor</code> we just defined.
cs: Řádky 10 – 14: Zde vytvoříme nový <code>ClutterStage</code>. Pak nastavíme jeho velikost pomocí definicí z předchozí části a adresu objektu <code>ClutterColor</code>, který jsme právě nadefinovali.

note: (itstool) path: note/p
en: A <code>ClutterStage</code> is the top-level <code>ClutterActor</code> onto which other <code>ClutterActor</code>s are placed.
cs: <code>ClutterStage</code> je <code>ClutterActor</code> nejvyšší úrovně, do kterého jsou umístěny ostatní objekty <code>ClutterActor</code>.

note: (itstool) path: item/p
en: Line 16: Here we call our function for getting the image file paths. We'll look at this in a bit.
cs: Řádek 16: Zde voláme naši funkci pro získání cest k souborům s obrázky. Pojďme se na to trochu podívat.

note: (itstool) path: item/p
en: Lines 18‒49: 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.
cs: Řádky 18 – 49: Zde nastavujeme objekty <code>ClutterActor</code>, načítáme obrázky a umisťujeme na správné místo na fotostěně. Podrobněji se na to podíváme v následující části.

note: (itstool) path: item/p
en: Line 52: Show the stage and <em>all its children</em>, meaning our images.
cs: Řádek 52: Zobrazí scénu a <em>všechny její potomky</em>, tzn. naše obrázky.

note: (itstool) path: item/p
en: Line 55: Start the Clutter main loop.
cs: Řádek 55: Spuštění hlavní smyčky Clutter.

note: (itstool) path: section/title
en: Setting up our image actors
cs: Nastavení našich obrázkových účinkujících

note: (itstool) path: note/p
en: In Clutter, an actor is the most basic visual element. Basically, everything you see is an actor.
cs: V knihovně Clutter je účinkující (actor) nejzákladnější vizuální prvek. Zjednodušeně, vše co vidíte, jsou účinkující.

note: (itstool) path: section/p
en: In this section, we are going to take a closer look at the loop used for setting up the <code>ClutterActor</code>s that will display our images.
cs: V této části se podrobněji podíváme na smyčku použitou k nastavení objektů <code>ClutterActor</code>, který budou zobrazovat naše obrázky.

note: (itstool) path: item/p
en: Line 7: Here we want to get the path at the <var>n</var>th location in the <code>GPtrArray</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>.
cs: Řádek 7: Zde chceme získat cestu na <var>n</var>-tém místě v poli <code>GPtrArray</code>, které obsahuje názvy cest k našim obrázkům. <var>n</var>-tá pozice je vypočítána na základě řádku <code>row</code> a sloupce <code>col</code>.

note: (itstool) path: item/p
en: Line 8‒23: 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.
cs: Řádek 8 – 23: Zde doopravdy vytvoříme <code>ClutterActor</code> a umístíme do něj obrázek. První argument je cesta, přes kterou přistupujeme přes náš uzel <code>GList</code>. Druhý argument je pro hlášení chyb, ale zde jej budeme ignorovat, abychom udrželi rozumnou délku příkladu.

note: (itstool) path: item/p
en: Line 47: 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.
cs: Řádek 47: Tímto se přidá <code>ClutterActor</code> do scény, což je vlastně kontejner. Předpokládá to také vlastnictví objektu <code>ClutterActor</code>, což je něco, kvůli čemuž byste se museli podívat hlouběji do vývoje GNOME. Drsné podrobnosti viz <link href="http://library.gnome.org/devel/gobject/stable/gobject-memory.html">dokumentace k <code>GObject</code></link>.

note: (itstool) path: section/title
en: Loading the images
cs: Načítání obrázků

note: (itstool) path: section/p
en: Let's take a short break from Clutter to see how we can get the file names from our image directory.
cs: Nyní se na chvíli ponechme Clutter stranou a podívejme se, jak získat názvy souborů z naší složky s obrázky.

note: (itstool) path: section/code
en: 
    static void
    load_image_path_names()
    {
        /* Ensure we can access the directory. */
        GError *error = NULL;
        GDir *dir = g_dir_open(IMAGE_DIR_PATH, 0, &amp;error);
        if(error)
        {
            g_warning("g_dir_open() failed with error: %s\n", error-&gt;message);
            g_clear_error(&amp;error);
            return;
        }
    
        img_paths = g_ptr_array_new_with_free_func (g_free);
    
        const gchar *filename = g_dir_read_name(dir);
        while(filename)
        {
            if(g_str_has_suffix(filename, ".jpg") || g_str_has_suffix(filename, ".png"))
            {
                gchar *path = g_build_filename(IMAGE_DIR_PATH, filename, NULL);
                g_ptr_array_add (img_paths, path);
            }
            filename = g_dir_read_name(dir);
        }
    }
cs: 
    static void
    load_image_path_names()
    {
        /* Ujištění, že máme přístup do složky. */
        GError *error = NULL;
        GDir *dir = g_dir_open(IMAGE_DIR_PATH, 0, &amp;error);
        if(error)
        {
            g_warning("g_dir_open() failed with error: %s\n", error-&gt;message);
            g_clear_error(&amp;error);
            return;
        }
    
        img_paths = g_ptr_array_new_with_free_func (g_free);
    
        const gchar *filename = g_dir_read_name(dir);
        while(filename)
        {
            if(g_str_has_suffix(filename, ".jpg") || g_str_has_suffix(filename, ".png"))
            {
                gchar *path = g_build_filename(IMAGE_DIR_PATH, filename, NULL);
                g_ptr_array_add (img_paths, path);
            }
            filename = g_dir_read_name(dir);
        }
    }

note: (itstool) path: item/p
en: Lines 5 and 12: This opens our directory or, if an error occurred, returns after printing an error message.
cs: Řádky 5 a 12: Otevře naši složku nebo, když se objeví chyba, vrátí se po vypsání chybové zprávy.

note: (itstool) path: item/p
en: Lines 16‒25: 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.
cs: Řádky 16 – 25: První řádek získá jiný název souboru z objektu <code>GDir</code>, který jsem otevřeli již dříve. Pokud se jednalo o soubor s obrázkem (což zkontrolujeme podle jeho přípony „.png“ nebo „.jpg“) ve složce, kterou zpracováváme, přidáme před název souboru cestu a celé to vložíme na začátek seznamu, který jsem dříve vytvořili. Nakonec se pokusíme získat následující název v cestě, a když je nějaký soubor nalezen, vrátíme se do smyčky.

note: (itstool) path: section/title
en: Set up the actors
cs: Nastavení účinkujících

note: (itstool) path: section/p
en: We now take a look at the sizing and positioning of <code>ClutterActor</code>s and also readying the <code>ClutterActor</code> for user interaction.
cs: Nyní se pojďme podívat na nastavení velikosti a polohy objektů <code>ClutterActor</code> a také na jejich přípravu pro komunikaci s uživatelem.

note: (itstool) path: section/code
en: 
    /* This function handles setting up and placing the rectangles. */
    static void
    initialize_actor(ClutterActor *actor, guint row, guint col)
    {
        clutter_actor_set_size(actor, THUMBNAIL_SIZE, THUMBNAIL_SIZE);
        clutter_actor_set_position(actor, col * THUMBNAIL_SIZE, row * THUMBNAIL_SIZE);
        clutter_actor_set_reactive(actor, TRUE);
    
        g_signal_connect(actor,
                         "button-press-event",
                         G_CALLBACK(actor_clicked_cb),
                         NULL);
    }
cs: 
    /* Tato funkce se stará o vytvoření a umístění obdélníků. */
    static void
    initialize_actor(ClutterActor *actor, guint row, guint col)
    {
        clutter_actor_set_size(actor, THUMBNAIL_SIZE, THUMBNAIL_SIZE);
        clutter_actor_set_position(actor, col * THUMBNAIL_SIZE, row * THUMBNAIL_SIZE);
        clutter_actor_set_reactive(actor, TRUE);
    
        g_signal_connect(actor,
                         "button-press-event",
                         G_CALLBACK(actor_clicked_cb),
                         NULL);
    }

note: (itstool) path: item/p
en: Line 7: Setting an actor reactive means that it reacts to events, such as <code>button-press-event</code> in our case. For Photo Wall, all <code>ClutterActor</code>s in the wall should initially be reactive.
cs: Řádek 7: Nastavení účinkujícího jako reagujícího znamená, že reaguje na události, jako je v našem případě <code>"button-press-event"</code>. Pro fotostěnu by měli být všechny objekty <code>ClutterActor</code> nastaveny jako reagující.

note: (itstool) path: item/p
en: Line 9‒12: Now we connect the <code>button-press-event</code> to the <code>actor_clicked_cb</code> callback which we will look at next.
cs: Řádek 9 – 12: Nyní připojíme <code>button-press-event</code> na zpětné volání <code>actor_clicked_cb</code>, na které se podíváme posléze.

note: (itstool) path: section/p
en: At this point we've got a wall of images that are ready to be viewed.
cs: V tomto bodě máme stěnu s obrázky, která je připravena k zobrazení.

note: (itstool) path: section/title
en: Reacting to the clicks
cs: Reakce na kliknutí

note: (itstool) path: section/code
en: 
    static gboolean
    actor_clicked_cb(ClutterActor *actor,
                     ClutterEvent *event,
                     gpointer      user_data)
    {
        /* Flag to keep track of our state. */
        static gboolean is_focused = FALSE;
        ClutterActorIter iter;
        ClutterActor *child;
    
        /* Reset the focus state on all the images */
        clutter_actor_iter_init (&amp;iter, clutter_actor_get_parent(actor));
        while (clutter_actor_iter_next(&amp;iter, &amp;child))
          clutter_actor_set_reactive(child, is_focused);
    
        clutter_actor_save_easing_state(actor);
        clutter_actor_set_easing_duration(actor, ANIMATION_DURATION_MS);
    
        if(is_focused)
        {
            /* Restore the old location and size. */
            clutter_actor_set_position(actor, unfocused_pos.x, unfocused_pos.y);
            clutter_actor_set_size(actor, THUMBNAIL_SIZE, THUMBNAIL_SIZE);
        }
        else
        {
            /* Save the current location before animating. */
            clutter_actor_get_position(actor, &amp;unfocused_pos.x, &amp;unfocused_pos.y);
            /* Only the currently focused image should receive events. */
            clutter_actor_set_reactive(actor, TRUE);
    
            /* Put the focused image on top. */
            clutter_actor_set_child_above_sibling(clutter_actor_get_parent(actor), actor, NULL);
    
            clutter_actor_set_position(actor, (STAGE_WIDTH - STAGE_HEIGHT) / 2.0, 0);
            clutter_actor_set_size(actor, STAGE_HEIGHT, STAGE_HEIGHT);
        }
    
        clutter_actor_restore_easing_state(actor);
    
        /* Toggle our flag. */
        is_focused = !is_focused;
    
        return TRUE;
    }
cs: 
    static gboolean
    actor_clicked_cb(ClutterActor *actor,
                     ClutterEvent *event,
                     gpointer      user_data)
    {
        /* Příznak, který bude uchovávat náš stav */
        static gboolean is_focused = FALSE;
        ClutterActorIter iter;
        ClutterActor *child;
    
        /* Vynuluje stav zaměření u všech obrázků */
        clutter_actor_iter_init (&amp;iter, clutter_actor_get_parent(actor));
        while (clutter_actor_iter_next(&amp;iter, &amp;child))
          clutter_actor_set_reactive(child, is_focused);
    
        clutter_actor_save_easing_state(actor);
        clutter_actor_set_easing_duration(actor, ANIMATION_DURATION_MS);
    
        if(is_focused)
        {
            /* Obnoví staré umístění a velikost */
            clutter_actor_set_position(actor, unfocused_pos.x, unfocused_pos.y);
            clutter_actor_set_size(actor, THUMBNAIL_SIZE, THUMBNAIL_SIZE);
        }
        else
        {
            /* Uloží aktuální umístění, než se začne animovat */
            clutter_actor_get_position(actor, &amp;unfocused_pos.x, &amp;unfocused_pos.y);
            /* Only the currently focused image should receive events. */
            clutter_actor_set_reactive(actor, TRUE);
    
            /* Vloží zaměřený obrázek nahoru */
            clutter_actor_set_child_above_sibling(clutter_actor_get_parent(actor), actor, NULL);
    
            clutter_actor_set_position(actor, (STAGE_WIDTH - STAGE_HEIGHT) / 2.0, 0);
            clutter_actor_set_size(actor, STAGE_HEIGHT, STAGE_HEIGHT);
        }
    
        clutter_actor_restore_easing_state(actor);
    
        /* Přepne náš příznak */
        is_focused = !is_focused;
    
        return TRUE;
    }

note: (itstool) path: item/p
en: 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.
cs: Řádek 1 – 4: Musíme zajistit, že naše funkce zpětného volání bude formálně odpovídat požadavkům signálu <code>button_clicked_event</code>. Například musíme použít jen první argument, konkrétně <code>ClutterActor</code>, na který bylo kliknuto.

note: (itstool) path: note/p
en: 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.
cs: Pár slov k argumentům, které v tomto příkladu nepoužíváme. <code>ClutterEvent</code> se liší podle toho, která událost je obsluhována. Například událost klávesy zapříčiní <code>ClutterKeyEvent</code>, ze které můžeme mimo jiné údaje zjistit, která klávesa byla zmáčknuta. Pro událost kliknutí myší získáte <code>ClutterButtonEvent</code>, ze kterého můžete zjistit souřadnice <code>x</code> a <code>y</code>. Na další typy objektu <code>ClutterEvent</code> se podívejte do dokumentace knihovny Clutter.

note: (itstool) path: note/p
en: The <code>user_data</code> is what one uses to pass data into 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.
cs: Argment <code>user_data</code> jsou data předávaná funkci. Může být předán například ukazatel na libovolná data, takže když potřebujete zpětnému volání předat více údajů, umístěte data do struktury a předejte adresu na ni.

note: (itstool) path: item/p
en: 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.
cs: Ředek: Vytvoříme statický příznak pro sledování stavu, ve kterém se nacházíme: režim stěny nebo režim zaměření. Začínáme v režimu stěny, kdy žádný obrázek nemá zaměření. Proto nastavíme počáteční hodnotu příznaku na <code>FALSE</code>.

note: (itstool) path: item/p
en: Line 12‒14: These set the image actors to receive events if they are focused.
cs: Řádek 12 – 14: Toto nastaví obrázkové účinkující, aby přijímali události, když jsou zaměření.

note: (itstool) path: item/p
en: Line 16‒17: Here we set the animation duration and save the current state.
cs: Řádek 16 – 17: Zde nastavíme délku trvání animace a uložíme aktuální stav.

note: (itstool) path: item/p
en: Lines 21‒23: Reaching this code means that one image currently has focus and we want to return to wall mode. Setting a position on a <code>ClutterActor</code> begins an animation with the duration that we set in line 17.
cs: Řádky 21 – 3: Dosažení tohoto místa znamená, že obrázek je právě zaměřen a my se chceme vrátit do režimu stěny. Nastavením pozice objektu <code>ClutterActor</code> začne animace v délce trvání nastavené na řádku 17.

note: (itstool) path: item/p
en: 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.
cs: Řádek 24: Dosažení tohoto místa v kódu znamená, že jsem právě v režimu stěny a chystáme se dát objektu <code>ClutterActor</code> zaměření. Uložíme zde počáteční pozici, abychom se na ni později mohli vrátit.

note: (itstool) path: item/p
en: 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.
cs: Řádek 25: Nastavení vlastnosti <code>reactive</code> objektu <code>ClutterActor</code> na <code>TRUE</code> zajistí, že bude <code>ClutterActor</code> reagovat na události. Ve stavu zaměření bude jediným účinkujícím, u kterého chceme, aby přijímal událost, ten, který je právě zobrazován. Kliknutí na účinkujícího jej vrátí na původní místo.

note: (itstool) path: item/p
en: Lines 27‒36: This is where we save the current position of the image, set it to receive events and then make it appear above the other images and start animating it to fill the stage.
cs: Řádek 27 – 36: Zde ukládáme aktuální pozici obrázku, nastavujeme jej, aby přijímal události a pak jej necháme objevit na ostatními obrázky a začneme jej animovat, aby zaplnil scénu.

note: (itstool) path: item/p
en: Line 39: Here we restore the easing state to what was set before we changed it in line 16.
cs: Řádek 39: Zde obnovíme uvolněný stav na hodnotu nastavenou, než jsme ji změnili na řádku 16.

note: (itstool) path: item/p
en: Line 42: Here we toggle the <code>is_focused</code> flag to the current state.
cs: Řádek 42: Zde přepneme příznak <code>is_focused</code> (je zaměřeno) na aktuální stav.

note: (itstool) path: item/p
en: 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.
cs: Jak už jsem se zmínili dříve, události přijímá <code>ClutterActor</code> s vyšší hodnotou <code>depth</code>, ale můžete to umožnit i ostatním objektům <code>ClutterActor</code> pod ním. Když je vráceno <code>TRUE</code>, předávání událostí dolů se zastaví, zatímco <code>FALSE</code> bude předávat události dolů.

note: (itstool) path: note/p
en: Remember, however, that to receive events the <code>ClutterActor</code>s must be set <code>reactive</code>.
cs: Pamatujte ale, že aby objekty <code>ClutterActor</code> přijímaly události, musí být nastavené jako <code>reactive</code> (reagující).

note: (itstool) path: section/p
en: All of the code should now be ready to go. All you need now is some pictures to load. By default, the pictures are loaded from a <file>berlin_images</file> directory. If you want, you can change the <code>#define IMAGE_DIR_PATH</code> line near the top to refer to your photo directory, or create a <file>berlin_images</file> directory by clicking <guiseq><gui>Project</gui><gui>New Directory...</gui></guiseq> and creating a <file>berlin_images</file> directory as a subdirectory of the <file>photo-wall</file> directory. Make sure to put at least twelve images in the directory!
cs: Veškerý kód by nyní měl být připraven k běhu. Vše, co nyní potřebujete, jsou nějaké obrázky k načtení. Ve výchozím stavu se obrázky načítají ze složky <file>berlin_images</file>. Jestli chcete, můžete změnit řádek <code>#define IMAGE_DIR_PATH</code> někde na začátku, který odkazuje na vaší složku s fotografiemi, nebo vytvořit složku <file>berlin_images</file> kliknutím na <guiseq><gui>Projekt</gui><gui>Nová složka…</gui></guiseq> a vytvořením složky <file>berlin_images</file> jako podsložky ve složce <file>photo-wall</file>. Do složky umístěte aspoň dvanáct obrázků!

note: (itstool) path: section/p
en: When you have done that, click <guiseq><gui>Build</gui><gui>Build Project</gui></guiseq> to build everything again, then <guiseq><gui>Run</gui><gui>Execute</gui></guiseq> to start the application.
cs: Až to budete mít přichystané, klikněte na <guiseq><gui>Sestavit</gui> <gui>Sestavit projekt</gui></guiseq>, aby se vše znovu sestavilo, a pak na <guiseq><gui>Spustit</gui> <gui>Spustit</gui></guiseq>, aby se spustila aplikace.

note: (itstool) path: section/p
en: If you haven't already done so, choose the <file>Debug/src/photo-wall</file> application in the dialog that appears. Finally, hit <gui>Run</gui> and enjoy!
cs: Pokud jste tak ještě neučinili, zvolte aplikaci <file>Debug/src/photo-wall</file> v dialogovém okně, které se objeví. Nakonec klikněte na <gui>Spustit</gui> a užijte si ji!

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="photo-wall/photo-wall.c">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="photo-wall/photo-wall.c">ukázkovým kódem</link>.

note: (itstool) path: info/desc
en: A widget which indicates progress visually
cs: Widget, který graficky znázorňuje průběh

note: (itstool) path: page/p
en: This ProgressBar "fills in" by a fraction of the bar until it is full.
cs: Tento ProgressBar je po částech „vyplňován“, dokud lišta není plná.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    static gboolean
    fill (gpointer   user_data)
    {
      GtkWidget *progress_bar = user_data;
    
      /*Get the current progress*/
      gdouble fraction;
      fraction = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (progress_bar));
    
      /*Increase the bar by 10% each time this function is called*/
      fraction += 0.1;
    
      /*Fill in the bar with the new fraction*/
      gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), fraction);
    
      /*Ensures that the fraction stays below 1.0*/
      if (fraction &lt; 1.0) 
        return TRUE;
      
      return FALSE;
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *progress_bar;
    
      gdouble fraction = 0.0;
    
      /*Create a window with a title, and a default size*/
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "ProgressBar Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 220, 20);
     
      /*Create a progressbar and add it to the window*/
      progress_bar = gtk_progress_bar_new ();
      gtk_container_add (GTK_CONTAINER (window), progress_bar);
    
      /*Fill in the given fraction of the bar. Has to be between 0.0-1.0 inclusive*/
      gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), fraction);
    
      /*Use the created fill function every 500 milliseconds*/
      g_timeout_add (500, fill, GTK_PROGRESS_BAR (progress_bar));
     
      gtk_widget_show_all (window);
    }
     
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
     
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
     
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    static gboolean
    fill (gpointer   user_data)
    {
      GtkWidget *progress_bar = user_data;
    
      /* Získá aktuální stav průběhu */
      gdouble fraction;
      fraction = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (progress_bar));
    
      /* Zvýší stav lišty o 10% při každém zavolání této funkce */
      fraction += 0.1;
    
      /* Vyplní lištu novým podílem */
      gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), fraction);
    
      /* Zajistí, že podíl nepřekročí hodnotu 1,0 */
      if (fraction &lt; 1.0) 
        return TRUE;
      
      return FALSE;
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *progress_bar;
    
      gdouble fraction = 0.0;
    
      /* Vytvoří okno s názvem, šířkou okraje a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "ProgressBar Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 220, 20);
     
      /* Vytvoří ukazatel průběhu a přidá jej do okna */
      progress_bar = gtk_progress_bar_new ();
      gtk_container_add (GTK_CONTAINER (window), progress_bar);
    
      /* Vyplní zadaný podíl lišty. Musí být v rozmezí 0,0 až 1,0 včetně */
      gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), fraction);
    
      /* Použije každých 500 milisekund funkci vyplňující lištu */
      g_timeout_add (500, fill, GTK_PROGRESS_BAR (progress_bar));
     
      gtk_widget_show_all (window);
    }
     
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
     
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
     
      return status;
    }

note: (itstool) path: info/desc
en: A bar which animates to indicate progress
cs: Lišta, která pomocí animací znázorňuje průběh

note: (itstool) path: div/p
en: Pressing any key stops and starts this ProgressBar.
cs: Zmáčknutí libovolné klávesy zastaví a spustí tento ProgressBar.

note: (itstool) path: page/p
en: This ProgressBar is stopped and started by pressing any key.
cs: Tento PrograssBar ze zastavuje a spouští zmáčknutím libovolné klávesy.

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class ProgressBarExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsprogressbar',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
                this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                           window_position: Gtk.WindowPosition.CENTER,
                                                           default_height: 20,
                                                           default_width: 220,
                                                           title: "ProgressBar Example"});
    
            // Create the progress bar
            this.progressBar = new Gtk.ProgressBar ();
            this._window.add(this.progressBar);
    
            // Start the function that pulses the bar every 100 milliseconds
            this.sourceID = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 100,
                                             this._barPulse.bind(this));
    
            // Connect a keypress event to the function that toggles the bar to start or stop pulsing
            this._window.connect("key-press-event", this._onKeyPress.bind(this));
    
                // Show the window and all child widgets
                this._window.show_all();
        }
    
        // Pulse the progressbar (unless it has been disabled by a keypress)
        _barPulse() {
            this.progressBar.pulse();
            return true;
        }
    
        // Start or stop the progressbar when a key is pressed
        _onKeyPress() {
            if (this.sourceID == 0)
                this.sourceID = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 100,
                                                 this._barPulse.bind(this));
            else {
                GLib.source_remove(this.sourceID);
                this.sourceID = 0;
            }
        }
    
    };
    
    // Run the application
    let app = new ProgressBarExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class ProgressBarExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsprogressbar',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
                this._window = new Gtk.ApplicationWindow({ application: this.application,
                                                           window_position: Gtk.WindowPosition.CENTER,
                                                           default_height: 20,
                                                           default_width: 220,
                                                           title: "ProgressBar Example"});
    
            // Vytvoří ukazatel průběhu
            this.progressBar = new Gtk.ProgressBar ();
            this._window.add(this.progressBar);
    
            // Spustí funkci, která pulzuje ukazatelem průběhu každých 100 milisekund
            this.sourceID = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 100,
                                             this._barPulse.bind(this));
    
            // Napojí událost zmáčknutí klávesy na funkci, která přepíná pulzování ukazatele průběhu
            this._window.connect("key-press-event", this._onKeyPress.bind(this));
    
                // Zobrazí okno a všechny jeho synovské widgety
                this._window.show_all();
        }
    
        // Pulzuje ukazatelem průběhu (pokud nebyl zakázán zmáčknutím klávesy)
        _barPulse() {
            this.progressBar.pulse();
            return true;
        }
    
        // Spustí a zastaví ukazatel průběhu při zmáčknátí klávesy
        _onKeyPress() {
            if (this.sourceID == 0)
                this.sourceID = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 100,
                                                 this._barPulse.bind(this));
            else {
                GLib.source_remove(this.sourceID);
                this.sourceID = 0;
            }
        }
    
    };
    
    // Spustí aplikaci
    let app = new ProgressBarExample ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: A widget which indicates progress visually.
cs: Widget, který graficky zobrazuje průběh.

note: (itstool) path: section/code
en: from gi.repository import GLib
    from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # a window
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="ProgressBar Example", application=app)
            self.set_default_size(220, 20)
    
            # a progressbar
            self.progress_bar = Gtk.ProgressBar()
            # add the progressbar to the window
            self.add(self.progress_bar)
    
            # the method self.pulse is called each 100 milliseconds
            # and self.source_id is set to be the ID of the event source
            # (i.e. the bar changes position every 100 milliseconds)
            self.source_id = GLib.timeout_add(100, self.pulse)
    
        # event handler
        # any signal from the keyboard controls if the progressbar stops/starts
        def do_key_press_event(self, event):
            # if the progressbar has been stopped (therefore source_id == 0 - see
            # "else" below), turn it back on
            if (self.source_id == 0):
                self.source_id = GLib.timeout_add(100, self.pulse)
            # if the bar is moving, remove the source with the ID of source_id
            # from the main context (stop the bar) and set the source_id to 0
            else:
                GLib.source_remove(self.source_id)
                self.source_id = 0
            # stop the signal emission
            return True
    
        # source function
        # the progressbar is in "activity mode" when this method is called
        def pulse(self):
            self.progress_bar.pulse()
            # call the function again
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import GLib
    from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # Okno
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="ProgressBar Example", application=app)
            self.set_default_size(220, 20)
    
            # Ukazatel průběhu
            self.progress_bar = Gtk.ProgressBar()
            # Přidá ukazatel průběhu do okna
            self.add(self.progress_bar)
    
            # Metoda self.pulse je volána každých 100 milisekund
            # a self.source_id je nastaveno na ID zdroje události
            # (tj. ukazatel změní polohu každých 100 milisekund)
            self.source_id = GLib.timeout_add(100, self.pulse)
    
        # Obsluha události
        # Libovolný signál od klávesnice řídí zastavení/spuštění ukazatele průběhu
        def do_key_press_event(self, event):
            # Jestliže byl ukazatel průběhu zastaven (proto se source_id == 0 - viz
            # "else" níže), znovu jej zapne
            if (self.source_id == 0):
                self.source_id = GLib.timeout_add(100, self.pulse)
            # Jestliže se ukazatel pohybuje, odstraní zdroj s ID source_id
            # z hlavního kontextu (zastaví ukazatel) a nastaví source_id na 0
            else:
                GLib.source_remove(self.source_id)
                self.source_id = 0
            # Zastaví vysílání signálu
            return True
    
        # Zdrojová funkce
        # Ukazatel průběhu je v "režimu aktivity", když je zavolána tato metoda
        def pulse(self):
            self.progress_bar.pulse()
            # Zavolá funkci znovu
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a ProgressBar widget
cs: Užitečné metody pro widget ProgressBar

note: (itstool) path: item/p
en: Instead of <code>pulse()</code>, that makes the bar go back and forth, if we want the ProgressBar to "fill in" a fraction (a <code>float</code> between <code>0.0</code> and <code>1.0</code> included) of the bar that has been completed, use <code>set_fraction(fraction)</code>.
cs: Místo <code>pulse()</code>, která způsobí pohyb lišty tam a zpět, můžeme chtít, aby <code>ProgressBar</code> vyplnil v příslušném poměru (desetinné číslo <code>float</code> v rozmezí <code>0.0</code> až <code>1.0</code> včetně) část lišty odpovídající tomu, co bylo z celku již dokončeno. K tomu se používá <code>set_fraction(fraction)</code>.

note: (itstool) path: item/p
en: To set a text and show it (superimposed over the bar) use <code>set_text(<var>"text"</var>)</code> and <code>set_show_text(True)</code>. If a text is not set and <code>set_show_text(True)</code> the text will be the percentage of the work that has been completed.
cs: Chcete-li nastavit text a zobrazit jej (přes lištu) použijte <code>set_text(<var>"text"</var>)</code> a <code>set_show_text(True)</code>. Pokud text nastaven není a použijete <code>set_show_text(True)</code>, budou textem procenta dokončené části.

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html">GLib - The Main Event Loop</link>
cs: <link href="http://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html">GLib – hlavní smyčka událostí</link>

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/gdk/stable/gdk-Keyboard-Handling">Gdk - Key Values</link>
cs: <link href="http://developer.gnome.org/gdk/stable/gdk-Keyboard-Handling">Gdk – hodnoty kláves</link>

note: (itstool) path: page/code
en: public class MyApplication : Gtk.Application {
    
    	Gtk.ProgressBar progress_bar;
    
    	protected override void activate () {
    		var window = new Gtk.ApplicationWindow (this);
    		window.set_title ("ProgressBar Example");
    		window.set_default_size (220, 20);
    
    		progress_bar = new Gtk.ProgressBar ();
    		window.add (progress_bar);
    		window.show_all ();
    
    		double fraction = 0.0;
    		progress_bar.set_fraction (fraction);
    		GLib.Timeout.add (500, fill);
    	}
    
    	bool fill () {
    		double fraction = progress_bar.get_fraction (); //get current progress
    		fraction += 0.1; //increase by 10% each time this function is called
    
    		progress_bar.set_fraction (fraction);
    
    		/* This function is only called by GLib.Timeout.add while it returns true; */
    		if (fraction &lt; 1.0)
    			return true;
    		return false;
    	}
    }
    
    public int main (string[] args) {
    	var progress_bar_application = new MyApplication ();
    	int status =  progress_bar_application.run (args);
    	return status;
    }
cs: public class MyApplication : Gtk.Application {
    
    	Gtk.ProgressBar progress_bar;
    
    	protected override void activate () {
    		var window = new Gtk.ApplicationWindow (this);
    		window.set_title ("ProgressBar Example");
    		window.set_default_size (220, 20);
    
    		progress_bar = new Gtk.ProgressBar ();
    		window.add (progress_bar);
    		window.show_all ();
    
    		double fraction = 0.0;
    		progress_bar.set_fraction (fraction);
    		GLib.Timeout.add (500, fill);
    	}
    
    	bool fill () {
    		double fraction = progress_bar.get_fraction (); //get current progress
    		fraction += 0.1; // Zvýší o 10% pokaždé, když je tato funkce zavolána is called
    
    		progress_bar.set_fraction (fraction);
    
    		/* Tato funkce je volána jen z GLib.Timeout.add, přičemž vrací true */
    		if (fraction &lt; 1.0)
    			return true;
    		return false;
    	}
    }
    
    public int main (string[] args) {
    	var progress_bar_application = new MyApplication ();
    	int status =  progress_bar_application.run (args);
    	return status;
    }

[ctx: text]
note: (itstool) path: info/title
en: Properties (Python)
cs: Vlastnosti (Python)

note: (itstool) path: info/desc
en: An explanation of properties, getters and setters.
cs: Vysvětlení vlastností a jejich získávání a nastavování.

note: (itstool) path: page/title
en: Properties
cs: Vlastnosti

note: (itstool) path: section/p
en: <em>Properties</em> describe the configuration and state of widgets. Each widget has its own particular set of properties. For example, a widget such as a button has the property <code>label</code> which contains the text of the widget. You can specify the name and value of any number of properties as keyword arguments when creating an instance of a widget. For example, to create a label with the text “Hello World”, an angle of 25 degrees, and aligned to the right, you can use:
cs: <em>Vlastnosti</em> popisují nastavení a stav widgetů. Každý widget má svoji vlastní konkrétní sadu vlastností. Například takový widget tlačítko má vlastnost <code>label</code>, která obsahuje text widgetu. Název a hodnotu libovolného počtu vlastností můžete zadat jako argumenty s klíčovými slovy při vytváření instance widgetu. Například k vytvoření popisku s textem „Hello World“, úhlem 25 stupňů a zarovnáním doprava, můžete použít:

note: (itstool) path: section/p
en: Alternatively, you can define these properties separately by using the method associated with it.
cs: Případně můžete tyto vlastnosti definovat postupně pomocí metod, které k nim patří.

note: (itstool) path: section/p
en: Once you have created such a label, you can get the text of the label with <code>label.get_label()</code>, and analogously for the other properties.
cs: Jakmile máte takovýto popisek vytvořený, můžete získat jeho text pomocí <code>label.get_label()</code> a obdobně i ostatní jeho vlastnosti.

note: (itstool) path: section/p
en: Instead of using getters and setters you can also get and set the properties with <code>get_property(<var>"prop-name"</var>)</code> and <code>set_property(<var>"prop-name"</var>, <var>value</var>)</code>, respectively.
cs: Místo jednotlivých metod pro získání a nastavení vlastností, můžete vlastnosti získat a nastavit pomocí <code>get_property(<var>"název-vlastnoti"</var>)</code> respektive <code>set_property(<var>"název-vlastnosti"</var>, <var>hodnota</var>)</code>.

note: (itstool) path: section/p
en: <link href="http://python-gtk-3-tutorial.readthedocs.org/en/latest/basics.html">Basics - Properties</link> in Python GTK+ 3 Tutorial
cs: <link href="http://python-gtk-3-tutorial.readthedocs.org/en/latest/basics.html">Základy – Vlastnosti</link> ve výuce GTK+ 3 v jazyce Python

note: (itstool) path: page/title
en: Tutorials, code samples and platform demos in Python
cs: Výuka, ukázky kódu a demonstrace platformy v jazyce Python

note: (itstool) path: section/title (itstool) path: page/title
en: Tutorial for beginners
cs: Výuka pro začátečníky

note: (itstool) path: info/desc
en: A choice from multiple checkbuttons
cs: Volba z více zaškrtávacích políček

note: (itstool) path: page/p
en: These radiobuttons report their activity in the terminal.
cs: Tyto skupinové přepínače oznamují svojí aktivitu v terminálu.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /*Signal handler for the "toggled" signal of the RadioButton*/
    static void
    button_toggled_cb (GtkWidget *button,
                       gpointer   user_data)
    {
      char *b_state;
      const char *button_label;
    
      if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
              b_state = "on";
      else {
              b_state = "off";
              g_print ("\n");
      }
    
      button_label = gtk_button_get_label (GTK_BUTTON (button));
    
      g_print ("%s was turned %s\n", button_label, b_state);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *grid;
      GtkWidget *window;
    
      GtkWidget *button1;
      GtkWidget *button2;
      GtkWidget *button3;
    
      /*Create a window with a set title and default size.
      Also, set a border width for the amount of space to leave
      inside the window*/
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "RadioButton Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 250, 100);
      gtk_container_set_border_width (GTK_CONTAINER(window), 20);
    
    
      /*Create an initial radio button*/
      button1 = gtk_radio_button_new_with_label (NULL, "Button 1");
    
      /*Create a second radio button, and add it to the same group as Button 1*/
      button2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (button1), 
                                                             "Button 2");
    
      /*Create a third button, and add it to the same group as Button 1*/
      button3 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (button1), 
                                                             "Button 3");
    
    
      /*Create a grid, attach the buttons, and position them accordingly*/
      grid = gtk_grid_new ();
      gtk_grid_attach (GTK_GRID (grid), button1, 0, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), button2, 0, 1, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), button3, 0, 2, 1, 1);
    
      /*Be sure to set the initial state of each button*/
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button2), TRUE);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button1), FALSE);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button3), FALSE);
    
      /*Connect the signal handlers (aka Callback functions) to the buttons*/
      g_signal_connect (GTK_TOGGLE_BUTTON (button1), "toggled", 
                        G_CALLBACK (button_toggled_cb), window);
      g_signal_connect (GTK_TOGGLE_BUTTON (button2), "toggled", 
                        G_CALLBACK (button_toggled_cb), window);
      g_signal_connect (GTK_TOGGLE_BUTTON (button3), "toggled", 
                        G_CALLBACK (button_toggled_cb), window);
    
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Obsluha signálu „toggled“ od widgetu RadioButton */
    static void
    button_toggled_cb (GtkWidget *button,
                       gpointer   user_data)
    {
      char *b_state;
      const char *button_label;
    
      if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
              b_state = "on";
      else {
              b_state = "off";
              g_print ("\n");
      }
    
      button_label = gtk_button_get_label (GTK_BUTTON (button));
    
      g_print ("%s was turned %s\n", button_label, b_state);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *grid;
      GtkWidget *window;
    
      GtkWidget *button1;
      GtkWidget *button2;
      GtkWidget *button3;
    
      /* Vytvoří okno s nastaveným názvem a výchozí velikostí.
         Rovněž se nastaví šířka okraje, aby bylo uvnitř okna ponecháno
         více místa */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "RadioButton Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 250, 100);
      gtk_container_set_border_width (GTK_CONTAINER(window), 20);
    
    
      /* Vytvoří první skupinový přepínač */
      button1 = gtk_radio_button_new_with_label (NULL, "Button 1");
    
      /* Vytvoří druhý skupinový přepínač a přidá jej do stejné skupiny jako
         Button 1 */
      button2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (button1), 
                                                             "Button 2");
    
      /* Vytvoří třetí skupinový přepínač a přidá jej do stejné skupiny jako
         Button 1 */
      button3 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (button1), 
                                                             "Button 3");
    
    
      /* Vytvoří mřížku, připojí přepínače a správně je umístí */
      grid = gtk_grid_new ();
      gtk_grid_attach (GTK_GRID (grid), button1, 0, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), button2, 0, 1, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), button3, 0, 2, 1, 1);
    
      /* Zajistí správné nastavení počátečního stavu každého z přepínačů */
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button2), TRUE);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button1), FALSE);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button3), FALSE);
    
      /* Připojí obsluhu signálu (neboli funkcí zpětného volání) k přepínačům */
      g_signal_connect (GTK_TOGGLE_BUTTON (button1), "toggled", 
                        G_CALLBACK (button_toggled_cb), window);
      g_signal_connect (GTK_TOGGLE_BUTTON (button2), "toggled", 
                        G_CALLBACK (button_toggled_cb), window);
      g_signal_connect (GTK_TOGGLE_BUTTON (button3), "toggled", 
                        G_CALLBACK (button_toggled_cb), window);
    
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: info/desc
en: Only one can be selected at a time
cs: V každý okamžik může být vybrán jej jeden

note: (itstool) path: page/p
en: RadioButtons are named after old-style car radios, which had buttons for switching between channel presets. Because the radio could only be tuned to one station at a time, only one button could be pressed in at a time; if you pressed a new one, the one that was already pressed in would pop back out. That's how these buttons work, too.
cs: Skupinový přepínač se anglicky se nazývá „rádiové tlačítko“ podle starých autorádií, která měla tlačítka pro přepínání kanálu. Rádio může mít v kterýkoliv okamžik naladěnu jen jednu stanici, takže když jste zmáčkli libovolné tlačítko, všechny ostatní vyskočily. Tyto skupinové přepínače fungují úplně stejně.

note: (itstool) path: page/p
en: Each RadioButton needs a text label and a group. Only one button in a group can be selected at a time. You don't name each group; you just set new RadioButtons to be part of the same group as an existing one. If you create a new one outside of a group, it automatically creates a new group for it to be part of.
cs: Každý widget <code>RadioButton</code> potřebuje popisek a skupinu. V kterýkoliv okamžik lze vybrat jen jeden skupinový přepínač ve skupině. Není třeba každou skupinu pojmenovat, stačí nastavit nový <code>RadioButton</code> jako součást skupiny, která již existuje. Když vytvoříte nový mimo jakoukoliv skupinu, automaticky se pro něj nový skupina vytvoří a stane se její součástí.

note: (itstool) path: section/code
en: 
    const RadioButtonExample = new Lang.Class({
        Name: 'RadioButton Example',
    
        // Create the application itself
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsradiobutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Connect 'activate' and 'startup' signals to the callback functions
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Callback function for 'activate' signal presents window when active
        _onActivate: function() {
            this._window.present();
        },
    
        // Callback function for 'startup' signal builds the UI
        _onStartup: function() {
            this._buildUI ();
        },
cs: 
    const RadioButtonExample = new Lang.Class({
        Name: 'RadioButton Example',
    
        // Vytvoří vlastní aplikaci
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsradiobutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate: function() {
            this._window.present();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function() {
            this._buildUI ();
        },

note: (itstool) path: section/p
en: All the code for this sample goes in the RadioButtonExample class. The above code creates a <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> for our widgets and window to go in.
cs: Všechen kód této ukázky je ve třídě <code>RadioButtonExample</code>. Výše uvedený kód vytvoří <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> pro naše widgety a okno, ve kterém budou.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI: function() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Travel Planning"});
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Travel Planning"});

note: (itstool) path: section/title
en: Creating the radiobuttons
cs: Vytvoření skupinových přepínačů

note: (itstool) path: section/code
en: 
            // Create a label for the first group of buttons
            this._placeLabel = new Gtk.Label ({label: "Where would you like to travel to?"});
cs: 
            // Vytvoří popisek pro první skupinu přepínačů
            this._placeLabel = new Gtk.Label ({label: "Where would you like to travel to?"});

note: (itstool) path: section/p
en: We use a <link xref="label.js">Gtk.Label</link> to set each group of RadioButtons apart. Nothing will stop you from putting RadioButtons from all different groups wherever you want, so if you want people to know which ones go together you need to organize things accordingly.
cs: Používáme <link xref="label.js">Gtk.Label</link> k oddělení jednotlivých skupin se skupinovými přepínači. Nic vám nebrání ve vložení všech možných skupin, kam vás napadne, takže jestli chcete, aby se v nich uživatelé vyznali, musíte je rozumně uspořádat.

note: (itstool) path: section/code
en: 
            // Create three radio buttons three different ways
            this._place1 = new Gtk.RadioButton ({label: "The Beach"});
    
            this._place2 = Gtk.RadioButton.new_from_widget (this._place1);
            this._place2.set_label ("The Moon");
    
            this._place3 = Gtk.RadioButton.new_with_label_from_widget (this._place1, "Antarctica");
            // this._place3.set_active (true);
cs: 
            // Vytvoří tři skupinové přepínače třemi různými způsoby
            this._place1 = new Gtk.RadioButton ({label: "The Beach"});
    
            this._place2 = Gtk.RadioButton.new_from_widget (this._place1);
            this._place2.set_label ("The Moon");
    
            this._place3 = Gtk.RadioButton.new_with_label_from_widget (this._place1, "Antarctica");
            // this._place3.set_active (true);

note: (itstool) path: section/p
en: Here are three different ways to create RadioButtons. The first is the usual way, where we create a new Gtk.RadioButton and assign its properties at the same time. The second and third use functions which automatically handle some of the properties; new_from_widget takes a single argument, the RadioButton that you want to put this new one in the same group as. Meanwhile, new_with_label_from_widget takes that and the RadioButton's label at the same time.
cs: Zde jsou tři různé způsoby, jak vytvořit skupinový přepínač. V prvním, obvyklém způsobu, vytvoříme nový <code>Gtk.RadioButton</code> a zároveň mu přiřadíme jeho vlastnosti. Druhý a třetí používá funkce, které automaticky obslouží některé vlastnosti. <code>new_from_widget</code> přebírá jeden argument, kterým je <code>RadioButton</code>, do jehož skupiny chcete zařadit i ten nový. Oproti tomu <code>new_with_label_from_widget</code> přebírá zároveň i popisek pro skupinový přepínač.

note: (itstool) path: section/p
en: The first RadioButton in a group is the one that's selected by default. Try uncommenting the last line in this sample code to see how you can set a different one to be the default selection.
cs: První <code>RadioButton</code> ve skupině je ten, který bude vybraný ve výchozím stavu. Zkuste zrušit zakomentování posledního řádku v tomto ukázkovém kódu, abyste viděli, jak můžete nastavit jiný jako vybraný ve výchozím stavu.

note: (itstool) path: section/code
en: 
            // Create a label for the second group of buttons
            this._thingLabel = new Gtk.Label ({label: "And what would you like to bring?" });
    
            // Create three more radio buttons
            this._thing1 = new Gtk.RadioButton ({label: "Penguins" });
            this._thing2 = new Gtk.RadioButton ({label: "Sunscreen", group: this._thing1 });
            this._thing3 = new Gtk.RadioButton ({label: "A spacesuit", group: this._thing1 });
cs: 
            // Vytvoří popisek pro druhou skupinu tlačítek
            this._thingLabel = new Gtk.Label ({label: "And what would you like to bring?" });
    
            // Vytvoří další tři skupinové přepínače
            this._thing1 = new Gtk.RadioButton ({label: "Penguins" });
            this._thing2 = new Gtk.RadioButton ({label: "Sunscreen", group: this._thing1 });
            this._thing3 = new Gtk.RadioButton ({label: "A spacesuit", group: this._thing1 });

note: (itstool) path: section/p
en: Here we create the label for the second group of buttons, and then create them all the same way.
cs: Zde vytvoříme popisek pro druhou skupinu přepínačů a všechny skupinové přepínače stejným způsobem vytvoříme.

note: (itstool) path: section/title
en: Creating the rest of the user interface
cs: Vytvoření zbytku uživatelského rozhraní

note: (itstool) path: section/code
en: 
            // Create a stock OK button
            this._okButton = new Gtk.Button ({
                label: 'gtk-ok',
                use_stock: 'true',
                halign: Gtk.Align.END });
    
            // Connect the button to the function which handles clicking it
            this._okButton.connect ('clicked', Lang.bind (this, this._okClicked));
cs: 
            // Vytvoří standardní tlačítko OK
            this._okButton = new Gtk.Button ({
                label: 'gtk-ok',
                use_stock: 'true',
                halign: Gtk.Align.END });
    
            // Napojí tlačítko na funkci, která zpracovává kliknutí na něj
            this._okButton.connect ('clicked', Lang.bind (this, this._okClicked));

note: (itstool) path: section/p
en: This code creates a <link xref="button.js">Gtk.Button</link> and binds it to a function which will show people a silly message when they click OK, depending on which RadioButtons were selected.
cs: Tento kód vytvoří <link xref="button.js">Gtk.Button</link> a napojí jej na funkci, která uživateli, když klikne na <gui>OK</gui>, zobrazí bláznivou zprávu podle vybraného skupinového přepínače.

note: (itstool) path: section/p
en: To make sure the button's "OK" label shows up properly in every language that GNOME is translated into, remember to use one of Gtk's <link href="https://developer.gnome.org/gtk3/3.4/gtk3-Stock-Items.html">stock button types</link>.
cs: Abyste zajistili, že tlačítko s popiskem <gui>OK</gui> bude správně zobrazeno ve všech národních jazycích, do kterých je GNOME přeloženo, nezapomeňte použít <link href="https://developer.gnome.org/gtk3/3.4/gtk3-Stock-Items.html">tlačítko Gtk standardního typu</link>.

note: (itstool) path: section/code
en: 
            // Create a grid to put the "place" items in
            this._places = new Gtk.Grid ();
    
            // Attach the "place" items to the grid
            this._places.attach (this._placeLabel, 0, 0, 1, 1);
            this._places.attach (this._place1, 0, 1, 1, 1);
            this._places.attach (this._place2, 0, 2, 1, 1);
            this._places.attach (this._place3, 0, 3, 1, 1);
    
            // Create a grid to put the "thing" items in
            this._things = new Gtk.Grid ({ margin_top: 50 });
    
            // Attach the "thing" items to the grid
            this._things.attach (this._thingLabel, 0, 0, 1, 1);
            this._things.attach (this._thing1, 0, 1, 1, 1);
            this._things.attach (this._thing2, 0, 2, 1, 1);
            this._things.attach (this._thing3, 0, 3, 1, 1);
    
            // Create a grid to put everything in
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_left: 40,
                margin_right: 50 });
    
            // Attach everything to the grid
            this._grid.attach (this._places, 0, 0, 1, 1);
            this._grid.attach (this._things, 0, 1, 1, 1);
            this._grid.attach (this._okButton, 0, 2, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
cs: 
            // Vytvoří mřížku pro položky v seznamu „místa“
            this._places = new Gtk.Grid ();
    
            // Připojí položky seznamu „místa“ do mřížky
            this._places.attach (this._placeLabel, 0, 0, 1, 1);
            this._places.attach (this._place1, 0, 1, 1, 1);
            this._places.attach (this._place2, 0, 2, 1, 1);
            this._places.attach (this._place3, 0, 3, 1, 1);
    
            // Vytvoří mřížku pro položky v seznamu „věci“
            this._things = new Gtk.Grid ({ margin_top: 50 });
    
            // Připojí položky seznamu „věci“ do mřížky
            this._things.attach (this._thingLabel, 0, 0, 1, 1);
            this._things.attach (this._thing1, 0, 1, 1, 1);
            this._things.attach (this._thing2, 0, 2, 1, 1);
            this._things.attach (this._thing3, 0, 3, 1, 1);
    
            // Vytvoří mřížku, do které se vše vloží
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_left: 40,
                margin_right: 50 });
    
            // Připojí vše do mřížky
            this._grid.attach (this._places, 0, 0, 1, 1);
            this._grid.attach (this._things, 0, 1, 1, 1);
            this._grid.attach (this._okButton, 0, 2, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);

note: (itstool) path: section/p
en: We use a separate <link xref="grid.js">Gtk.Grid</link> to organize each group of radio buttons. This way we can change the layout with less fuss later on. The second Grid has a margin on top, to visually separate the two sets of choices.
cs: Používáme samostatné mřížky <link xref="grid.js">Gtk.Grid</link> k uspořádání skupin skupinových přepínačů. Díky tomu můžeme později měnit rozvržení bez větší námahy. Druhá mřížka má nahoře okraj, aby opticky oddělila dvě sady voleb.

note: (itstool) path: section/p
en: After we've organized them, we put them into a third, master Grid, along with the OK button. Then we attach that to the window.
cs: Když máme skupinové přepínače uspořádané, vložíme je do třetí, hlavní, mřížky spolu s tlačítkem <gui>OK</gui>. Tu pak připojíme do okna.

note: (itstool) path: section/code
en: 
            // Show the window and all child widgets
            this._window.show_all();
        },
cs: 
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        },

note: (itstool) path: section/p
en: Finally, we tell the window and everything inside it to become visible when the application is run.
cs: Nakonec řekneme oknu a všemu v něm, aby se stali viditelnými, kdy se aplikace spustí.

note: (itstool) path: section/code
en: 
        _okClicked: function () {
    
            // Create a popup that shows a silly message
            this._travel = new Gtk.MessageDialog ({
                transient_for: this._window,
                modal: true,
                message_type: Gtk.MessageType.OTHER,
                buttons: Gtk.ButtonsType.OK,
                text: this._messageText() });
    
            // Show the popup
            this._travel.show();
    
            // Bind the OK button to the function that closes the popup
            this._travel.connect ("response", Lang.bind (this, this._clearTravelPopUp));
    
        },
cs: 
        _okClicked: function () {
    
            // Vytvoří vyskakovací dialogové okno, které zobrazí bláznivou zprávu
            this._travel = new Gtk.MessageDialog ({
                transient_for: this._window,
                modal: true,
                message_type: Gtk.MessageType.OTHER,
                buttons: Gtk.ButtonsType.OK,
                text: this._messageText() });
    
            // Zobrazí dialogové okno
            this._travel.show();
    
            // Napojí tlačítko OK na funkci, která zavře vyskakovací dialogové okno
            this._travel.connect ("response", Lang.bind (this, this._clearTravelPopUp));
    
        },

note: (itstool) path: section/p
en: When you click OK, a <link xref="messagedialog.js">Gtk.MessageDialog</link> appears. This function creates and displays the popup window, then binds its OK button to a function that closes it. What text appears in the popup depends on the _messageText() function, which returns a different value depending on which set of options you chose.
cs: Když kliknete na <gui>OK</gui>, objeví se <link xref="messagedialog.js">Gtk.MessageDialog</link>. Tato funkce vytvoří a zobrazí vyskakovací okno a napojí jeho tlačítko <gui>OK</gui> na funkci, která okno zavře. Jaký text se v okně objeví, závisí na funkci <code>_messageText()</code>, která vrací různé hodnoty podle toho, kterou sadu voleb vyberete.

note: (itstool) path: section/code
en: 
        _messageText: function() {
    
            // Create a silly message for the popup depending on what you selected
            var stringMessage = "";
    
            if (this._place1.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "Penguins love the beach, too!";
    
                else if (this._thing2.get_active())
                    stringMessage = "Make sure to put on that sunscreen!";
    
                else stringMessage = "Are you going to the beach in space?";
    
            }
    
            else if (this._place2.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "The penguins will take over the moon!";
    
                else if (this._thing2.get_active())
                    stringMessage = "A lack of sunscreen will be the least of your problems!";
    
                else stringMessage = "You'll probably want a spaceship, too!";
            }
    
            else if (this._place3.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "The penguins will be happy to be back home!";
    
                else if (this._thing2.get_active())
                    stringMessage = "Antarctic sunbathing may be hazardous to your health!";
    
                else stringMessage = "Try bringing a parka instead!";
            }
    
            return stringMessage;
    
        },
cs: 
        _messageText: function() {
    
            // Vytvoří bláznivou zprávu pro dialogové okno podle toho, co jste vybrali
            var stringMessage = "";
    
            if (this._place1.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "Penguins love the beach, too!";
    
                else if (this._thing2.get_active())
                    stringMessage = "Make sure to put on that sunscreen!";
    
                else stringMessage = "Are you going to the beach in space?";
    
            }
    
            else if (this._place2.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "The penguins will take over the moon!";
    
                else if (this._thing2.get_active())
                    stringMessage = "A lack of sunscreen will be the least of your problems!";
    
                else stringMessage = "You'll probably want a spaceship, too!";
            }
    
            else if (this._place3.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "The penguins will be happy to be back home!";
    
                else if (this._thing2.get_active())
                    stringMessage = "Antarctic sunbathing may be hazardous to your health!";
    
                else stringMessage = "Try bringing a parka instead!";
            }
    
            return stringMessage;
    
        },

note: (itstool) path: section/p
en: The get_active() method is how we can tell which RadioButton's pressed in. This function returns a different silly message depending on which set of buttons was pressed. Its return value is used as the MessageDialog's text property.
cs: Metoda <code>get_active()</code> je způsob, jak zjistit, který skupinový přepínač je „zmáčknutý“. Tato funkce vrací různé bláznivé zprávy v závislosti na tom, které skupinové přepínače jsou vybrané. Vrácená hodnota se použije jako vlastnost <code>"text"</code> v dialogovém okně se zprávou.

note: (itstool) path: section/p
en: This function is called when the MessageDialog's OK button is pressed. It simply makes the popup go away.
cs: Tato funkce je volána, když je zmáčknuto tlačítko <gui>OK</gui> v dialogovém okně se zprávou. Jednoduše dialogové okno odklidí.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new RadioButtonExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new RadioButtonExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished RadioButtonExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci konečné třídy RadioButtonExample a aplikaci spustíme.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class RadioButtonExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsradiobutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Travel Planning"});
    
            // Create a label for the first group of buttons
            this._placeLabel = new Gtk.Label ({label: "Where would you like to travel to?"});
    
            // Create three radio buttons three different ways
            this._place1 = new Gtk.RadioButton ({label: "The Beach"});
    
            this._place2 = Gtk.RadioButton.new_from_widget (this._place1);
            this._place2.set_label ("The Moon");
    
            this._place3 = Gtk.RadioButton.new_with_label_from_widget (this._place1, "Antarctica");
            // this._place3.set_active (true);
    
            // Create a label for the second group of buttons
            this._thingLabel = new Gtk.Label ({label: "And what would you like to bring?" });
    
            // Create three more radio buttons
            this._thing1 = new Gtk.RadioButton ({label: "Penguins" });
            this._thing2 = new Gtk.RadioButton ({label: "Sunscreen", group: this._thing1 });
            this._thing3 = new Gtk.RadioButton ({label: "A spacesuit", group: this._thing1 });
    
            // Create a stock OK button
            this._okButton = new Gtk.Button ({
                label: 'gtk-ok',
                use_stock: 'true',
                halign: Gtk.Align.END });
    
            // Connect the button to the function which handles clicking it
            this._okButton.connect ('clicked', this._okClicked.bind(this));
    
            // Create a grid to put the "place" items in
            this._places = new Gtk.Grid ();
    
            // Attach the "place" items to the grid
            this._places.attach (this._placeLabel, 0, 0, 1, 1);
            this._places.attach (this._place1, 0, 1, 1, 1);
            this._places.attach (this._place2, 0, 2, 1, 1);
            this._places.attach (this._place3, 0, 3, 1, 1);
    
            // Create a grid to put the "thing" items in
            this._things = new Gtk.Grid ({ margin_top: 50 });
    
            // Attach the "thing" items to the grid
            this._things.attach (this._thingLabel, 0, 0, 1, 1);
            this._things.attach (this._thing1, 0, 1, 1, 1);
            this._things.attach (this._thing2, 0, 2, 1, 1);
            this._things.attach (this._thing3, 0, 3, 1, 1);
    
            // Create a grid to put everything in
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_left: 40,
                margin_right: 50 });
    
            // Attach everything to the grid
            this._grid.attach (this._places, 0, 0, 1, 1);
            this._grid.attach (this._things, 0, 1, 1, 1);
            this._grid.attach (this._okButton, 0, 2, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _okClicked() {
    
            // Create a popup that shows a silly message
            this._travel = new Gtk.MessageDialog ({
                transient_for: this._window,
                modal: true,
                message_type: Gtk.MessageType.OTHER,
                buttons: Gtk.ButtonsType.OK,
                text: this._messageText() });
    
            // Show the popup
            this._travel.show();
    
            // Bind the OK button to the function that closes the popup
            this._travel.connect ("response", this._clearTravelPopUp.bind(this));
    
        }
    
        _messageText() {
    
            // Create a silly message for the popup depending on what you selected
            var stringMessage = "";
    
            if (this._place1.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "Penguins love the beach, too!";
    
                else if (this._thing2.get_active())
                    stringMessage = "Make sure to put on that sunscreen!";
    
                else stringMessage = "Are you going to the beach in space?";
    
            }
    
            else if (this._place2.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "The penguins will take over the moon!";
    
                else if (this._thing2.get_active())
                    stringMessage = "A lack of sunscreen will be the least of your problems!";
    
                else stringMessage = "You'll probably want a spaceship, too!";
            }
    
            else if (this._place3.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "The penguins will be happy to be back home!";
    
                else if (this._thing2.get_active())
                    stringMessage = "Antarctic sunbathing may be hazardous to your health!";
    
                else stringMessage = "Try bringing a parka instead!";
            }
    
            return stringMessage;
    
        }
    
        _clearTravelPopUp() {
            this._travel.destroy();
        }
    };
    
    // Run the application
    let app = new RadioButtonExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class RadioButtonExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsradiobutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Travel Planning"});
    
            // Vytvoří popisek pro první skupinu přepínačů
            this._placeLabel = new Gtk.Label ({label: "Where would you like to travel to?"});
    
            // Vytvoří tři skupinové přepínače třemi různými způsoby
            this._place1 = new Gtk.RadioButton ({label: "The Beach"});
    
            this._place2 = Gtk.RadioButton.new_from_widget (this._place1);
            this._place2.set_label ("The Moon");
    
            this._place3 = Gtk.RadioButton.new_with_label_from_widget (this._place1, "Antarctica");
            // this._place3.set_active (true);
    
            // Vytvoří popisek pro druhou skupinu tlačítek
            this._thingLabel = new Gtk.Label ({label: "And what would you like to bring?" });
    
            // Vytvoří další tři skupinové přepínače
            this._thing1 = new Gtk.RadioButton ({label: "Penguins" });
            this._thing2 = new Gtk.RadioButton ({label: "Sunscreen", group: this._thing1 });
            this._thing3 = new Gtk.RadioButton ({label: "A spacesuit", group: this._thing1 });
    
            // Vytvoří standardní tlačítko OK
            this._okButton = new Gtk.Button ({
                label: 'gtk-ok',
                use_stock: 'true',
                halign: Gtk.Align.END });
    
            // Napojí tlačítko na funkci, která zpracovává kliknutí na něj
            this._okButton.connect ('clicked', this._okClicked.bind(this));
    
            // Vytvoří mřížku pro položky v seznamu „místa“
            this._places = new Gtk.Grid ();
    
            // Připojí položky seznamu „místa“ do mřížky
            this._places.attach (this._placeLabel, 0, 0, 1, 1);
            this._places.attach (this._place1, 0, 1, 1, 1);
            this._places.attach (this._place2, 0, 2, 1, 1);
            this._places.attach (this._place3, 0, 3, 1, 1);
    
            // Připojí položky seznamu „věci“ do mřížky
            this._things = new Gtk.Grid ({ margin_top: 50 });
    
            // Připojí položky seznamu „věci“ do mřížky
            this._things.attach (this._thingLabel, 0, 0, 1, 1);
            this._things.attach (this._thing1, 0, 1, 1, 1);
            this._things.attach (this._thing2, 0, 2, 1, 1);
            this._things.attach (this._thing3, 0, 3, 1, 1);
    
            // Vytvoří mřížku, do které se vše vloží
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_left: 40,
                margin_right: 50 });
    
            // Připojí vše do mřížky
            this._grid.attach (this._places, 0, 0, 1, 1);
            this._grid.attach (this._things, 0, 1, 1, 1);
            this._grid.attach (this._okButton, 0, 2, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _okClicked() {
    
            // Vytvoří vyskakovací dialogové okno, které zobrazí bláznivou zprávu
            this._travel = new Gtk.MessageDialog ({
                transient_for: this._window,
                modal: true,
                message_type: Gtk.MessageType.OTHER,
                buttons: Gtk.ButtonsType.OK,
                text: this._messageText() });
    
            // Zobrazí dialogové okno
            this._travel.show();
    
            // Napojí tlačítko OK na funkci, která zavře vyskakovací dialogové okno
            this._travel.connect ("response", this._clearTravelPopUp.bind(this));
    
        }
    
        _messageText() {
    
            // Vytvoří bláznivou zprávu pro dialogové okno podle toho, co jste vybrali
            var stringMessage = "";
    
            if (this._place1.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "Penguins love the beach, too!";
    
                else if (this._thing2.get_active())
                    stringMessage = "Make sure to put on that sunscreen!";
    
                else stringMessage = "Are you going to the beach in space?";
    
            }
    
            else if (this._place2.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "The penguins will take over the moon!";
    
                else if (this._thing2.get_active())
                    stringMessage = "A lack of sunscreen will be the least of your problems!";
    
                else stringMessage = "You'll probably want a spaceship, too!";
            }
    
            else if (this._place3.get_active()) {
    
                if (this._thing1.get_active())
                    stringMessage = "The penguins will be happy to be back home!";
    
                else if (this._thing2.get_active())
                    stringMessage = "Antarctic sunbathing may be hazardous to your health!";
    
                else stringMessage = "Try bringing a parka instead!";
            }
    
            return stringMessage;
    
        }
    
        _clearTravelPopUp() {
            this._travel.destroy();
        }
    };
    
    // Spustí aplikaci
    let app = new RadioButtonExample ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: Mutually exclusive buttons.
cs: Navzájem se vylučující přepínače

note: (itstool) path: page/p
en: Three RadioButtons. You can see in the terminal if they are turned off or on.
cs: Tři skupinové přepínače. V terminálu uvidíte, když dojde k jejich přepnutí.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="RadioButton Example", application=app)
            self.set_default_size(250, 100)
            self.set_border_width(20)
    
            # a new radiobutton with a label
            button1 = Gtk.RadioButton(label="Button 1")
            # connect the signal "toggled" emitted by the radiobutton
            # with the callback function toggled_cb
            button1.connect("toggled", self.toggled_cb)
    
            # another radiobutton, in the same group as button1
            button2 = Gtk.RadioButton.new_from_widget(button1)
            # with label "Button 2"
            button2.set_label("Button 2")
            # connect the signal "toggled" emitted by the radiobutton
            # with the callback function toggled_cb
            button2.connect("toggled", self.toggled_cb)
            # set button2 not active by default
            button2.set_active(False)
    
            # another radiobutton, in the same group as button1,
            # with label "Button 3"
            button3 = Gtk.RadioButton.new_with_label_from_widget(
                button1, "Button 3")
            # connect the signal "toggled" emitted by the radiobutton
            # with the callback function toggled_cb
            button3.connect("toggled", self.toggled_cb)
            # set button3 not active by default
            button3.set_active(False)
    
            # a grid to place the buttons
            grid = Gtk.Grid.new()
            grid.attach(button1, 0, 0, 1, 1)
            grid.attach(button2, 0, 1, 1, 1)
            grid.attach(button3, 0, 2, 1, 1)
            # add the grid to the window
            self.add(grid)
    
        # callback function
        def toggled_cb(self, button):
            # a string to describe the state of the button
            state = "unknown"
            # whenever the button is turned on, state is on
            if button.get_active():
                state = "on"
            # else state is off
            else:
                state = "off"
            # whenever the function is called (a button is turned on or off)
            # print on the terminal which button was turned on/off
            print(button.get_label() + " was turned " + state)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="RadioButton Example", application=app)
            self.set_default_size(250, 100)
            self.set_border_width(20)
    
            # Nový skupinový přepínač s popiskem
            button1 = Gtk.RadioButton(label="Button 1")
            # Napojí signál "toggled" vyslaný skupinovým přepínačem
            # na funkci zpětného volání toggled_cb
            button1.connect("toggled", self.toggled_cb)
    
            # Další skupinový přepínač, ve stejné skupině jako button1
            button2 = Gtk.RadioButton.new_from_widget(button1)
            # S popiskem "Button 2"
            button2.set_label("Button 2")
            # Napojí signál "toggled" vyslaný skupinovým přepínačem
            # na funkci zpětného volání toggled_cb
            button2.connect("toggled", self.toggled_cb)
            # Nastaví button2 jako neaktivní ve výchozím stavu
            button2.set_active(False)
    
            # Další skupinový přepínač, ve stejné skupině jako button1
            # S popiskem "Button 3"
            button3 = Gtk.RadioButton.new_with_label_from_widget(
                button1, "Button 3")
            # Napojí signál "toggled" vyslaný skupinovým přepínačem
            # na funkci zpětného volání toggled_cb
            button3.connect("toggled", self.toggled_cb)
            # Nastaví button3 jako neaktivní ve výchozím stavu
            button3.set_active(False)
    
            # Mřížka pro umístění tlačítek
            grid = Gtk.Grid.new()
            grid.attach(button1, 0, 0, 1, 1)
            grid.attach(button2, 0, 1, 1, 1)
            grid.attach(button3, 0, 2, 1, 1)
            # Přidá mřížku do okna
            self.add(grid)
    
        # Funkce zpětného volání
        def toggled_cb(self, button):
            # Řetězec popisující stav skupinového přepínače
            state = "unknown"
            # Kdykoliv je skupinový přepínač zapnut, je stav "on"
            if button.get_active():
                state = "on"
            # Jinak je stav "off"
            else:
                state = "off"
            # Kdykoliv je funkce zavolána (skupinový přepínač je zapnut nebo vypnut)
            # vypíše se do terminálu, který skupinový přepínač byl zapnut/vypnut
            print(button.get_label() + " was turned " + state)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a RadioButton widget
cs: Užitečné metody pro widget RadioButton

note: (itstool) path: section/p
en: In line 16 the signal <code>"toggled"</code> is connected to the callback function <code>toggled_cb()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 16 je signál <code>"toggled"</code> napojen na funkci zpětného volání <code>toggled_cb()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: section/p
en: As seen in <link xref="properties.py"/>, instead of <code>button1 = Gtk.RadioButton(label="Button 1")</code> we could create the button and label it with
cs: Jak jste mohli vidět v lekci <link xref="properties.py"/>, místo <code>button1 = Gtk.RadioButton(label="Button 1")</code> bychom mohli vytvořit tlačítko a pak mu nastavit popisek:

note: (itstool) path: section/p
en: Yet another way to create a new RadioButton with a label is <code>button1 = Gtk.RadioButton.new_with_label(None, "Button 1")</code> (the first argument is the group of the radiobuttons, which we can get with <code>get_group()</code>, the second argument is the label).
cs: Ještě jeden způsob, jak vytvořit nový skupinový přepínač s popiskem je <code>button1 = Gtk.RadioButton.new_with_label(None, "Button 1")</code> (první argument je skupina skupinových přepínačů, kterou můžeme získat pomocí <code>get_group()</code>, druhý argument je text popisku).

note: (itstool) path: info/desc
en: A choice from multiple CheckButtons.
cs: Volba z více zaškrtávacích políček

note: (itstool) path: page/p
en: These RadioButtons report their activity in the terminal.
cs: Tyto skupinové přepínače oznamují svoji aktivitu v terminálu.

note: (itstool) path: page/code
en: public class MyWindow : Gtk.ApplicationWindow {
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "RadioButton Example");
    
    		this.border_width = 20;
    		this.set_default_size (250, 100);
    
    		/* We demonstrate 3 different RadioButton creation methods */
    
    		//Create a Radio Button
    		var button1 = new Gtk.RadioButton (null);
    		button1.set_label ("Button 1");
    
    		//Create a RadioButton with a label, and add it to the same group as button1.
    		var button2 = new Gtk.RadioButton.with_label (button1.get_group(),"Button 2");
    
    		//Create a RadioButton with a label, adding it to button1's group.
    		var button3 = new Gtk.RadioButton.with_label_from_widget (button1, "Button 3");
    
    		//Attach the buttons to a grid.
    		var grid = new Gtk.Grid ();
    		grid.attach (button1, 0, 0, 1, 1);
    		grid.attach (button2, 0, 1, 1, 1);
    		grid.attach (button3, 0, 2, 1, 1);
    
    		//Add the button to the window.
    		this.add (grid);
    
    		//Connect the signal handlers (aka. callback functions) to the buttons.
    		button1.toggled.connect (button_toggled_cb);
    		button2.toggled.connect (button_toggled_cb);
    		button3.toggled.connect (button_toggled_cb);
    	}
    
    	void button_toggled_cb (Gtk.ToggleButton button)
    	{
    		var state = "unknown";
    
    		if (button.get_active ())
    			state = "on";
    		else {
    			state = "off";
    			print ("\n");
    		}
    		print (button.get_label() + " was turned " + state + "\n");
    	}
    }
    
    public class MyApplication : Gtk.Application {
    	protected override void activate () {
    
    		//Show all of the things.
    		new MyWindow (this).show_all ();
    	}
    
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    }
    
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: public class MyWindow : Gtk.ApplicationWindow {
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "RadioButton Example");
    
    		this.border_width = 20;
    		this.set_default_size (250, 100);
    
    		/* Ukážeme si 3 různé metody vytvoření RadioButton */
    
    		// Vytvoří Radio Button
    		var button1 = new Gtk.RadioButton (null);
    		button1.set_label ("Button 1");
    
    		// Vytvoří RadioButton s popiskem a přidá jej do stejné skupiny, jako je button1
    		var button2 = new Gtk.RadioButton.with_label (button1.get_group(),"Button 2");
    
    		// Vytvoří RadioButton s popiskem a přidá jej do skupiny skupinového přepínač button1
    		var button3 = new Gtk.RadioButton.with_label_from_widget (button1, "Button 3");
    
    		// Připojí skupinové přepínače do mřížky
    		var grid = new Gtk.Grid ();
    		grid.attach (button1, 0, 0, 1, 1);
    		grid.attach (button2, 0, 1, 1, 1);
    		grid.attach (button3, 0, 2, 1, 1);
    
    		// Přidá mřížku do okna
    		this.add (grid);
    
    		// Napojí obsluhu signálu (neboli funkce zpětného volání) ke skupinovým přepínačům
    		button1.toggled.connect (button_toggled_cb);
    		button2.toggled.connect (button_toggled_cb);
    		button3.toggled.connect (button_toggled_cb);
    	}
    
    	void button_toggled_cb (Gtk.ToggleButton button)
    	{
    		var state = "unknown";
    
    		if (button.get_active ())
    			state = "on";
    		else {
    			state = "off";
    			print ("\n");
    		}
    		print (button.get_label() + " was turned " + state + "\n");
    	}
    }
    
    public class MyApplication : Gtk.Application {
    	protected override void activate () {
    
    		// Vše zobrazí
    		new MyWindow (this).show_all ();
    	}
    
    	internal MyApplication () {
    		Object (application_id: "org.example.MyApplication");
    	}
    }
    
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

[ctx: text]
note: (itstool) path: info/title
en: Record collection (JavaScript)
cs: Sbírka alb (JavaScript)

note: (itstool) path: info/desc
en: Create a small database application for ordering your music collection
cs: Jak vytvořit malou databázovou aplikaci pro roztřídění vaší hudební sbírky.

note: (itstool) path: page/title
en: Record collection
cs: Sbírka alb

note: (itstool) path: item/p
en: How to connect to a database using libgda
cs: Jak se připojit k databázi pomocí libgda.

note: (itstool) path: item/p
en: How to insert and browse records in a database table
cs: Jak vložit záznam do databázové tabulky a jak záznamy procházet.

note: (itstool) path: section/p
en: This demo uses the Javascript language. We are going to demonstrate how to connect and use a database from a GTK program, by using the GDA (GNOME Data Access) library. Thus you also need this library installed.
cs: Tato ukázka používá programovací jazyk JavaScript. Budeme předvádět připojení k databázi a její použití z programu GTK pomocí knihovny GDA (GNOME Data Access). Z toho důvodu potřebujete mít tuto knihovnu nainstalovanou.

note: (itstool) path: section/p
en: GNOME Data Access (GDA) is library whose purpose is to provide universal access to different kinds and types of data sources. This goes from traditional relational database systems, to any imaginable kind of data source such as a mail server, a LDAP directory, etc. For more information, and for a full API and documentation, visit the <link href="http://library.gnome.org/devel/libgda/stable/">GDA website</link>.
cs: GNOME Data Access (GDA) je knihovna, jejímž učelem je poskytovat univerzální přístup do různých druhů a typů datových zdrojů. Ty sahají od tradičních relačních databázových systémů až po jakékoliv představitelné datové zdroje, jako je poštovní server nebo adresář LDAP. Více informací a ucelenou dokumentaci k API najdete na <link href="http://library.gnome.org/devel/libgda/stable/">webových stránkách GDA</link>.

note: (itstool) path: section/p
en: Although a big part of the code is related to user interface (GUI), we are going to focus our tutorial on the database parts (we might mention other parts we think are relevant though). To know more about Javascript programs in GNOME, see the <link xref="image-viewer.js">Image Viewer program</link> tutorial.
cs: Přestože velká část kódu souvisí s uživatelským rozhraním, hodláme zaměřit tuto lekci na databázovou část (i když jiné části můžeme též zmínit, pokud uvidíme nějakou souvislost). Jestli se chcete dozvědět více o programování v jazyce JavaScript v GNOME, podívejte se na lekci <link xref="image-viewer.js">Prohlížeč obrázků</link>.

note: (itstool) path: item/p
en: Choose <gui>Generic Javascript</gui> from the <gui>JS</gui> tab, click <gui>Forward</gui>, and fill-out your details on the next few pages. Use <file>record-collection</file> as project name and directory.
cs: Na kartě <gui>JS</gui> zvolte <gui>Obecný JavaScript</gui>, klikněte na <gui>Pokračovat</gui> a na několika následujících stránkách vyplňte své údaje. Jako název projektu a složky použijte <file>record-collection</file>.

note: (itstool) path: item/p
en: Click <gui>Finished</gui> and the project will be created for you. Open <file>src/main.js</file> from the <gui>Project</gui> or <gui>File</gui> tabs. It contains very basic example code.
cs: Klikněte na <gui>Dokončit</gui> a vytvoří se vám projekt. Otevřete <file>src/main.js</file> na kartě <gui>Projekt</gui> nebo <gui>Soubor</gui>. Měl by obsahovat úplně základní příklad kódu.

note: (itstool) path: section/title
en: Program Structure
cs: Struktura programu

note: (itstool) path: section/p
en: This demo is a simple GTK application (with a single window) capable of inserting records into a database table as well as browsing all records of the table. The table has two fields: <code>id</code>, an integer, and <code>name</code>, a varchar. The first section (on the top) of the application allows you to insert a record into the table. The last section (bottom) allows you to see all the records of that table. Its content is refreshed every time a new record is inserted and on the application startup.
cs: Tato ukázka je jednoduchou aplikací GTK (s jedním oknem) se schopností vkládat záznamy do databázové tabulky a procházet je. Tabulka má dvě pole: <code>id</code> (celé číslo) a <code>name</code> (varchar). V první části aplikace (nahoře) můžete vkládat záznamy do tabulky. V poslední části (dole) můžete vidět všechny záznamy v tabulce. Zobrazení obsahu se aktualizuje pokaždé, když je vložen nový záznam a při spuštění aplikace.

note: (itstool) path: section/title
en: Starting the fun
cs: Začíná zábava

note: (itstool) path: section/p
en: Let's start by examining the skeleton of the program:
cs: Začněme prozkoumáním kostry programu:

note: (itstool) path: item/p
en: Lines 1‒4: Initial imports. Pay special attention to line 3, which tells Javascript to import the GDA library, our focus in this tutorial.
cs: Řádek 1 – 4: Inicializační importy. Zvláštní pozornost věnujte řádku 3, který říká, aby JavaScript naimportovat knihovnu GDA, na kterou se tato lekce zaměřuje.

note: (itstool) path: item/p
en: Lines 6‒17: Define our <code>Demo</code> class. Pay special attention to lines 13‒15, where we call 3 methods which will do the whole job. They will be detailed below.
cs: Řádek 6 – 17: Definuje naši třídu <code>Demo</code>. Zvláštní pozornost věnujte řádkům 13 – 15, kde se volají 3 metody, které udělají celou práci. Podrobněji to bude vysvětleno dále.

note: (itstool) path: item/p
en: Lines 19‒23: Start the application.
cs: Řádek 19 – 23: Spuštění aplikace.

note: (itstool) path: section/title
en: Designing the application
cs: Návrh aplikace

note: (itstool) path: section/p
en: Let's take a look at the <code>setupWindow</code> method. It is responsible for creating the User Interface (UI). As UI is not our focus, we will explain only the relevant parts.
cs: Podívejme se na metodu <code>setupWindow</code>. Ta zodpovídá za vytvoření uživatelského rozhraní. Protože uživatelským rozhraním se teď nezabýváme, vysvětlíme si jen podstatné části.

note: (itstool) path: section/code
en: 
      setupWindow: function () {
        this.window = new Gtk.Window ({title: "Data Access Demo", height_request: 350});
        this.window.connect ("delete-event", function () {
          Gtk.main_quit();
          return true;
          });
    
        // main box
        var main_box = new Gtk.Box ({orientation: Gtk.Orientation.VERTICAL, spacing: 5});
        this.window.add (main_box);
    
        // first label
        var info1 = new Gtk.Label ({label: "&lt;b&gt;Insert a record&lt;/b&gt;", xalign: 0, use_markup: true});
        main_box.pack_start (info1, false, false, 5);
    
        // "insert a record" horizontal box
        var insert_box = new Gtk.Box ({orientation: Gtk.Orientation.HORIZONTAL, spacing: 5});
        main_box.pack_start (insert_box, false, false, 5);
    
        // ID field
        insert_box.pack_start (new Gtk.Label ({label: "ID:"}), false, false, 5);
        this.id_entry = new Gtk.Entry ();
        insert_box.pack_start (this.id_entry, false, false, 5);
    
        // Name field
        insert_box.pack_start (new Gtk.Label ({label: "Name:"}), false, false, 5);
        this.name_entry = new Gtk.Entry ({activates_default: true});
        insert_box.pack_start (this.name_entry, true, true, 5);
    
        // Insert button
        var insert_button = new Gtk.Button ({label: "Insert", can_default: true});
        insert_button.connect ("clicked", Lang.bind (this, this._insertClicked));
        insert_box.pack_start (insert_button, false, false, 5);
        insert_button.grab_default ();
    
        // Browse textview
        var info2 = new Gtk.Label ({label: "&lt;b&gt;Browse the table&lt;/b&gt;", xalign: 0, use_markup: true});
        main_box.pack_start (info2, false, false, 5);
        this.text = new Gtk.TextView ({editable: false});
        var sw = new Gtk.ScrolledWindow ({shadow_type:Gtk.ShadowType.IN});
        sw.add (this.text);
        main_box.pack_start (sw, true, true, 5);
    
        this.count_label = new Gtk.Label ({label: "", xalign: 0, use_markup: true});
        main_box.pack_start (this.count_label, false, false, 0);
    
        this.window.show_all ();
      },
cs: 
      setupWindow: function () {
        this.window = new Gtk.Window ({title: "Data Access Demo", height_request: 350});
        this.window.connect ("delete-event", function () {
          Gtk.main_quit();
          return true;
          });
    
        // Hlavní box
        var main_box = new Gtk.Box ({orientation: Gtk.Orientation.VERTICAL, spacing: 5});
        this.window.add (main_box);
    
        // První popisek
        var info1 = new Gtk.Label ({label: "&lt;b&gt;Insert a record&lt;/b&gt;", xalign: 0, use_markup: true});
        main_box.pack_start (info1, false, false, 5);
    
        // Vodorovný box pro "Insert a record"
        var insert_box = new Gtk.Box ({orientation: Gtk.Orientation.HORIZONTAL, spacing: 5});
        main_box.pack_start (insert_box, false, false, 5);
    
        // Pole ID
        insert_box.pack_start (new Gtk.Label ({label: "ID:"}), false, false, 5);
        this.id_entry = new Gtk.Entry ();
        insert_box.pack_start (this.id_entry, false, false, 5);
    
        // Pole Name
        insert_box.pack_start (new Gtk.Label ({label: "Name:"}), false, false, 5);
        this.name_entry = new Gtk.Entry ({activates_default: true});
        insert_box.pack_start (this.name_entry, true, true, 5);
    
        // Tlačítko Insert
        var insert_button = new Gtk.Button ({label: "Insert", can_default: true});
        insert_button.connect ("clicked", Lang.bind (this, this._insertClicked));
        insert_box.pack_start (insert_button, false, false, 5);
        insert_button.grab_default ();
    
        // TextView pro prohlížení
        var info2 = new Gtk.Label ({label: "&lt;b&gt;Browse the table&lt;/b&gt;", xalign: 0, use_markup: true});
        main_box.pack_start (info2, false, false, 5);
        this.text = new Gtk.TextView ({editable: false});
        var sw = new Gtk.ScrolledWindow ({shadow_type:Gtk.ShadowType.IN});
        sw.add (this.text);
        main_box.pack_start (sw, true, true, 5);
    
        this.count_label = new Gtk.Label ({label: "", xalign: 0, use_markup: true});
        main_box.pack_start (this.count_label, false, false, 0);
    
        this.window.show_all ();
      },

note: (itstool) path: item/p
en: Lines 22 and 27: Create the 2 entries (for the two fields) in which users will type something to get inserted in the database.
cs: Řádky 22 a 27: Vytvoří 2 vstupní pole (pro dvě databázová pole), do kterých uživatel bude psát to, co chce do databáze vložit.

note: (itstool) path: item/p
en: Lines 31‒34: Create the Insert button. We connect its <code>clicked</code> signal to the <code>_insertClicked</code> private method of the class. This method is detailed below.
cs: Řádek 31 – 34: Vytvoří tlačítko „Insert“. Jeho signál <code>"clicked"</code> napojíme na soukromou metodu <code>_insertClicked</code> třídy. Tato metoda je podrobněji rozebrána níže.

note: (itstool) path: item/p
en: Line 39: Create the widget (<code>TextView</code>) where we will show the contents of the table.
cs: Řádek 39: Vytvoří widget (<code>TextView</code>), ve kterém budeme zobrazovat obsah tabulky.

note: (itstool) path: item/p
en: Line 44: Create the label where we will show the number of records in the table. Initially it's empty, it will be updated later.
cs: Řádek 44: Vytvoří popisek, ve kterém budeme zobrazovat počet záznamů v tabulce. Na začátku je prázdný, později bude aktualizován.

note: (itstool) path: section/title
en: Connecting to and initializing the database
cs: Připojení k databázi a její inicializace

note: (itstool) path: section/p
en: The code which makes the connection to the database is in the <code>setupDatabase</code> method below:
cs: Kód, který provádí připojení do databáze je v metodě <code>setupDatabase</code> níže:

note: (itstool) path: item/p
en: Lines 2‒3: Create the GDA's <code>Connection</code> object. We must supply to its constructor some properties:
cs: Rádky 2 – 3: Vytvoří objekt <code>Connection</code> z knihovny GDA. Jeho konstruktoru musíme poskytnout některé vlastnosti:

note: (itstool) path: item/p
en: <code>provider</code>: One of GDA's supported providers. GDA supports SQLite, MySQL, PostgreSQL, Oracle and many others. For demo purposes we will use a SQLite database, as it comes installed by default in most distributions and it is simple to use (it just uses a file as a database).
cs: <code>provider</code>: Jeden z podporovaných poskytovatelů v knihovně GDA. Podporovány jsou SQLite, MySQL, PostgreSQL, Oracle a řada dalších. Pro předváděcí účely použijeme databázi SQLite, protože je standardně předinstalovaná ve většině distribucí a je jednoduchá na používání (prostě používá soubor jako databázi).

note: (itstool) path: item/p
en: <code>cnc_string</code>: The connection string. It may change from provider to provider. The syntax for SQLite is: <code>DB_DIR=<var>PATH</var>;DB_NAME=<var>FILENAME</var></code>. In this demo we are accessing a database called gnome_demo in the user home dir (note the call to GLib's <code>get_home_dir</code> function).
cs: <code>cnc_string</code>: Připojovací řetězec. Může si lišit poskytovatel od poskytovatele. Pro SQLite je syntax: <code>DB_DIR=<var>CESTA</var>;DB_NAME=<var>NÁZEV_SOUBORU</var></code>. V této ukázce přistupujeme k databázi s názvem gnome_demo v domovské složce uživatele (všimněte si volání funkce <code>get_home_dir</code>).

note: (itstool) path: note/p
en: If the provider is not supported by GDA, or if the connection string is missing some element, line 2 will raise an exception. So, in real life we should handle it with JavaScript's statement <code>try</code>...<code>catch</code>.
cs: V případě, že poskytovatel není v GDA podporován nebo že v připojovacím řetězci schází nějaká část, vyvolá řádek 2 výjimku. V reálném použití bychom ji měli obsloužit konstrukcí <code>try</code> … <code>catch</code> jazyka JavaScript.

note: (itstool) path: item/p
en: Line 4: Open the connection. In the SQLite provider, if the database does not exist, it will be created in this step.
cs: Řádek 4: Otevře připojení. U poskytovatele SQLite, když databáze neexistuje, dojde v tomto kroku k jejímu vytvoření.

note: (itstool) path: item/p
en: Lines 6‒10: Try to do a simple select to check if the table exists (line 7). If it does not exist (because the database was just created), this command will raise an exception, which is handled by the <code>try</code>...<code>catch</code> block. If it is the case, we run the create table statement (line 9).
cs: Řádky 6 – 10: Zkusí udělat jednoduchý dotaz, aby se ověřilo, že tabulka existuje (řádek 7). Pokud neexistuje (protože databáze byla teprve vytvořena), vyvolá tento příkaz výjimku, která se obslouží v bloku <code>try</code> … <code>catch</code>. V tomto případě provedeme příkaz, který tabulku vytvoří (řádek 9).

note: (itstool) path: item/p
en: In order to run the SQL commands above we are using the GDA connection methods <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.
cs: Ke spuštění příkazů SQL výše používáme metody připojení GDA s názvem <code>execute_select_command</code> a <code>execute_non_select_command</code>. Ty jsou jednoduché na použití a požadují jen dva argumenty: objekt <code>Connection</code> a příkaz SQL, který se má zpracovat.

note: (itstool) path: section/p
en: At this point we have the database set up, and are ready to use it.
cs: V tuto chvíli máme vytvořenu databázi a jsme připraveni ji použít.

note: (itstool) path: section/title
en: Selecting
cs: Vybírání

note: (itstool) path: section/p
en: After connecting to the database, our demo's constructor calls the <code>selectData</code> method. It is responsible for getting all the records in the table and showing them on the <code>TextView</code> widget. Let's take a look at it:
cs: Po připojení do databáze konstruktor v naší ukázce zavolá metodu <code>selectData</code>. Ta zodpovídá za získání všech záznamů z tabulky a jejich zobrazení ve widgetu <code>TextView</code>. Pojďme se na to podívat:

note: (itstool) path: item/p
en: Line 2: The <code>SELECT</code> command. We are using the GDA connection's <code>execute_select_command</code> method for that. It returns a <code>DataModel</code> object, which is later used to retrieve the rows.
cs: Řádek 2: Příkaz <code>SELECT</code>. K tomu používáme metodu připojení GDA s názvem <code>execute_select_command</code>. Vrací objekt <code>DataModel</code>, který je později použit k získání řádků.

note: (itstool) path: item/p
en: Line 3: Create an <code>Iter</code> object, which is used to iterate over the <code>DataModel</code>'s records.
cs: Řádek 3: Vytvoří objekt <code>Iter</code>, který se používá k procházení záznamů v <code>DataModel</code>.

note: (itstool) path: item/p
en: Line 7: Loop through all the records, fetching them with the help of the <code>Iter</code> object. At this point, the <code>iter</code> variable contains the actual, retrieved data. Its <code>move_next</code> method returns <code>false</code> when it reaches the last record.
cs: Řádek 7: Ve smyčce prochází všechny záznamy, které získává pomocí objektu <code>Iter</code>. V totmo místě proměnná <code>iter</code> obsahuje aktuálně získaná data. Jeho metoda <code>move_next</code> vrací <code>false</code>, když je dosažen poslední záznam.

note: (itstool) path: item/p
en: Lines 8‒9: We do two things in each line:
cs: Řádek 8 – 9: Na každém řádku děláme dvě věci:

note: (itstool) path: item/p
en: Use <code>Iter</code>'s method <code>get_value_at</code>, which requires only one argument: the column number to retrieve, starting at 0. As our <code>SELECT</code> command returns only two columns, we are retrieving columns 0 and 1.
cs: Použijeme metodu <code>get_value_at</code> třídy <code>Iter</code>, která požaduje jen jeden argument: číslo sloupce, který se má získat, počítáno od 0. Náš příkaz <code>SELECT</code> vrací dva sloupce, takže získáváme sloupce 0 a 1.

note: (itstool) path: item/p
en: The method <code>get_value_at</code> returns the field in GLib's <code>GValue</code> format. A simple way to convert this format to a string is by using GDA's global function <code>value_stringify</code>. That's what we are doing here, and we store the results in the variables <code>id_field</code> and <code>name_field</code>.
cs: Metoda <code>get_value_at</code> vrací pole ve formátu <code>GValue</code> knihovny GLib. Jednoduchým způsobem, jak převést tento formát na řetězec, je použít globální funkci knihovny GLib <code>value_stringify</code>. Což je přesně to, co zde děláme a výsledky pak uložíme do proměnných <code>id_field</code> a <code>name_field</code>.

note: (itstool) path: item/p
en: Line 11: Concatenate the two fields to make one text line, separated by <code>"=&gt;"</code>, and store it in the <code>text</code> variable.
cs: Řádek 11: Spojí dvě pole, aby vytvořila jeden textový řádek, přičemž jsou oddělená pomocí <code>"=&gt;"</code>, a uloží je do proměnné <code>text</code>.

note: (itstool) path: item/p
en: Line 14: After the loop is finished, we have all the records formatted in the <code>text</code> variable. In this line we just set the contents of the <code>TextView</code> with that variable.
cs: Řádek 14: Když je smyčka dokončená, máme všechny záznamy naformátované v proměnné <code>text</code>. V tomto řádku pomocí ní nastavíme obsah widgetu <code>TextView</code>.

note: (itstool) path: item/p
en: Line 15: Display the number of records in the table, making use of the <code>DataModel</code>'s <code>get_n_rows</code> method.
cs: Řádek 15: Zobrazí počet záznamů v tabulce pomocí metody <code>get_n_rows</code> objektu <code>DataModel</code>.

note: (itstool) path: section/title
en: Inserting
cs: Vkládání

note: (itstool) path: section/p
en: OK, we know how to connect to a database and how to select rows from a table. Now it's time to do an <code>INSERT</code> on the table. Do you remember above, in the method <code>setupWindow</code> we connected the <gui>Insert</gui> button's <code>clicked</code> signal to the method <code>_insertClicked</code>? Let's see the implementation of this method.
cs: Nuže, nyní víme, jak se připojit k databázi a jak vybrat řádky z tabulky. Nyní je čas na vkládání do tabulky pomocí <code>INSERT</code>. Pamatujete si z dřívějška, jak jsem v metodě <code>setupWindow</code> napojili signál <code>"clicked"</code> od tlačítka <gui>Insert</gui> na metodu <code>_insertClicked</code>? Pojďme se podívat na implementaci této metody.

note: (itstool) path: section/p
en: We have learned how to use the GDA connection's methods <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:
cs: Naučili jsme se, jako používat metody připojení GDA s názvy <code>execute_select_command</code> a <code>execute_non_select_command</code>, které slouží k rychlému provedení příkazů SQL v databázi. GDA umožňuje vytvořit výraz SQL nepřímo, pomocí jejího objektu <code>SqlBuilder</code>. Jaké to přináší výhody? GDA vygeneruje výraz SQL dynamicky a ten bude platný pro použitého poskytovatele připojení (použije se varianta SQL, kterou používá onen poskytovatel). Pojďme se podívat na kód:

note: (itstool) path: item/p
en: Lines 2‒3: Check if the user filled all the fields. The code for the private method <code>_validateFields</code> is really simple and you can read it in the full demo source code.
cs: Řádky 2 – 3: Zkontroluje se, jestli uživatel vyplnil všechna pole. Kód soukromé metody <code>_validateFields</code> je opravdu jednoduchý a můžete si jej přečíst v kompletním kódu této ukázky.

note: (itstool) path: item/p
en: Line 5: The faster way of doing the <code>INSERT</code>. It's commented out as we want to show how to use the <code>SqlBuilder</code> object to build a SQL statement portable across databases.
cs: Řádek 5: Rychlejší způsob, jak provést <code>INSERT</code>. Zde je zakomentováno, protože chceme ukázat, jak použít objekt <code>SqlBuilder</code> k sestavení výrazu SQL přenositelného mezi databázemi.

note: (itstool) path: item/p
en: Line 7: Create the <code>SqlBuilder</code> object. We must pass the type of statement we are going to build. It can be <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code> or <code>DELETE</code>.
cs: Řádek 7: Vytvoří objekt <code>SqlBuilder</code>. Musíme předat typ výrazu, který se chystáme sestavit. Může to být <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code> nebo <code>DELETE</code>.

note: (itstool) path: item/p
en: Line 8: Set the name of the table on which the built statement will operate (it will generate <code>INSERT INTO demo</code>)
cs: Řádek 8: Nastaví název tabulky, nad kterou bude sestavený výraz operovat (vygeneruje <code>INSERT INTO demo</code>)

note: (itstool) path: item/p
en: Lines 9‒10: Set the fields and its values that will be part of the statement. The first argument is the field name (as in the table). The second one is the value for that field.
cs: Řádek 9 – 10: Nastaví pole a jejich hodnoty, které budou součástí výrazu. První argument je název pole (tak, jak je v tabulce). Druhý je hodnota pro toto pole.

note: (itstool) path: item/p
en: Line 11: Get the dynamically generated <code>Statement</code> object, which represents a SQL statement.
cs: Řádek 11: Získá dynamicky vygenerovaný objekt <code>Statement</code>, který představuje výraz SQL.

note: (itstool) path: item/p
en: Line 12: Finally, execute the SQL statement (<code>INSERT</code>).
cs: Řádek 12: Nakonec se provede výraz SQL (<code>INSERT</code>).

note: (itstool) path: item/p
en: Line 14: Clear the id and name fields on the screen. The code for the private method <code>_clearFields</code> is really simple and you can read it in the full demo source code.
cs: Řádek 14: Smaže pole id a name na obrazovce. Kód pro soukromou metodu <code>_clearFields</code> je opravdu jednoduchý a můžete si jej přečíst v kompletním zdrojovém kódu ukázky.

note: (itstool) path: item/p
en: Line 15: Refresh the view on the screen by doing another <code>SELECT</code>.
cs: Řádek 15: Aktualizuje zobrazení na obrazovce provedením jiného výrazu <code>SELECT</code>.

note: (itstool) path: note/p
en: You can also make use of parameters while building the statement. By using the <code>SqlBuilder</code> objects and parameters you are less subject to attacks like SQL injection. Check the <link href="http://library.gnome.org/devel/libgda/stable/">GDA documentation</link> for more information about parameters.
cs: Můžete také použít parametrické sestavení výrazu. Pomocí objektů <code>SqlBuilder</code> a parametrů budu výrazy méně náchylné k útokům, jako je SQL injection. Na další informace o parametrech se podívejte do <link href="http://library.gnome.org/devel/libgda/stable/">dokumentace k GDA</link>.

note: (itstool) path: section/p
en: All of the code you need should now be in place, so try running the code. You now have a database for your record collection!
cs: Všechen kód, který potřebujete, je již na svém místě, takže jej pojďme zkusit spustit. Nyní máte databázi pro svoji sbírku alb.

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="record-collection/record-collection.js">reference code</link>.
cs: Pokud v této lekci narazíte na nějaké problémy, porovnejte si svůj kód s tímto <link href="record-collection/record-collection.js">ukázkovým kódem</link>.

note: (itstool) path: item/p
en: Returned if an action widget has no response id, or if the dialog gets programmatically hidden or destroyed
cs: Je vráceno, když widget akce nemá žádné ID odpovědi nebo když je dialogové okno programově skryto nebo zlikvidováno

note: (itstool) path: item/p
en: Generic response id, not used by GTK+ dialogs
cs: ID obecné odpovědi, v dialogových oknech GTK+ se nepoužívá

note: (itstool) path: item/p
en: Returned if the dialog is deleted
cs: Je vráceno, když je dialogové okno smazáno

note: (itstool) path: item/p
en: Returned by OK buttons in GTK+ dialogs
cs: Vrací tlačítko <gui>OK</gui> v dialogovém okně GTK+

note: (itstool) path: item/p
en: Returned by Cancel buttons in GTK+ dialogs
cs: Vrací tlačítko <gui>Cancel</gui> v dialogovém okně GTK+

note: (itstool) path: item/p
en: Returned by Close buttons in GTK+ dialogs
cs: Vrací tlačítko <gui>Close</gui> v dialogovém okně GTK+

note: (itstool) path: item/p
en: Returned by Yes buttons in GTK+ dialogs
cs: Vrací tlačítko <gui>Yes</gui> v dialogovém okně GTK+

note: (itstool) path: item/p
en: Returned by No buttons in GTK+ dialogs
cs: Vrací tlačítko <gui>No</gui> v dialogovém okně GTK+

note: (itstool) path: item/p
en: Returned by Apply buttons in GTK+ dialogs
cs: Vrací tlačítko <gui>Apply</gui> v dialogovém okně GTK+

note: (itstool) path: item/p
en: Returned by Help buttons in GTK+ dialogs
cs: Vrací tlačítko <gui>Help</gui> v dialogovém okně GTK+

note: (itstool) path: info/desc
en: A slider widget for selecting a value from a range
cs: Widget stupnice pro výběr hodnoty z nějakého rozsahu

note: (itstool) path: page/p
en: Slide the scales!
cs: Jezděte po stupnici!

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* This is the callback function. 
     * It is a handler function which reacts to the signal. 
     * In this case, it will notify the user the value of their scale as a label.
     */
    static void
    hscale_moved (GtkRange *range,
                  gpointer  user_data)
    {
       GtkWidget *label = user_data;
    
       /* Get the value of the range, and convert it into a string which will be
        * used as a new label for the horizontal scale.
        * %.0f - stands for a double that will have 0 decimal places.
        */
       gdouble pos = gtk_range_get_value (range);
       /* Note: Using g_strdup_printf returns a string that must be freed. 
        * (In which is done below)
        */
       gchar *str = g_strdup_printf ("Horizontal scale is %.0f", pos);
       gtk_label_set_text (GTK_LABEL (label), str);
    
       g_free(str);
    }
    
    
    
    /* This is the second callback function. It is a handler function which 
     * reacts to the signal. It does the same thing as the function above, except with
     * the vertical scale.
     */
    static void
    vscale_moved (GtkRange *range,
                  gpointer  user_data)
    {
       GtkWidget *label = user_data;
       
       gdouble pos = gtk_range_get_value (range);
       /* %.1f - stands for a double that will have 1 decimal place */
       gchar *str = g_strdup_printf ("Vertical scale is %.1f", pos);
       gtk_label_set_text (GTK_LABEL (label), str);
    
       
       g_free (str);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      /* Declare variables */
      GtkWidget *window;
      GtkWidget *h_scale;
      GtkWidget *v_scale;
      GtkWidget *hlabel;
      GtkWidget *vlabel;
      GtkWidget *grid;
    
      /* The Adjustment object represents a value 
       * which has an associated lower and upper bound.
       */
      GtkAdjustment *hadjustment;
      GtkAdjustment *vadjustment;
    
      /* Create a window with a title and a default size */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Scale Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
      gtk_container_set_border_width (GTK_CONTAINER (window), 5);
    
      /* Two labels to be shown in the window */
      hlabel = gtk_label_new ("Move the scale handle...");
      vlabel = gtk_label_new ("Move the scale handle...");
    
       
      /* gtk_adjustment_new takes six parameters, three of which 
       * may be difficult to understand:
       * step increment- move the handle with the arrow keys on your keyboard to see.
       * page increment - move the handle by clicking away from it 
       * on the scale to see.
       * page size - not used here.
       */
      hadjustment = gtk_adjustment_new (0, 0, 100, 5, 10, 0);
      vadjustment = gtk_adjustment_new (50, 0, 100, 5, 10, 0); 
    
      /* Create the Horizontal scale, making sure the 
       * digits used have no decimals.
       */
      h_scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, hadjustment);
      gtk_scale_set_digits (GTK_SCALE (h_scale), 0); 
    
      /* Allow it to expand horizontally (if there's space), and 
       * set the vertical alignment
       */
      gtk_widget_set_hexpand (h_scale, TRUE);
      gtk_widget_set_valign (h_scale, GTK_ALIGN_START);
      
      /* Connecting the "value-changed" signal for the horizontal scale 
       * to the appropriate callback function. 
       * take note that GtkRange is part of GtkScale's Object Hierarchy.
       */
      g_signal_connect (h_scale, 
                        "value-changed", 
                        G_CALLBACK (hscale_moved), 
                        hlabel);
    
    
    
      /* Create the Vertical scale. This time, we will see what happens 
       * when the digits aren't initially set.
       */
      v_scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, vadjustment);
      gtk_widget_set_vexpand (v_scale, TRUE);
    
      /* Connecting the "value-changed" signal for the vertical scale to 
       * the appropriate callback function.
       */
      g_signal_connect (v_scale, 
                        "value-changed", 
                        G_CALLBACK (vscale_moved), 
                        vlabel);
    
      /* Create a grid and arrange everything accordingly */
      grid = gtk_grid_new ();
      gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
      gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE);
      gtk_grid_attach (GTK_GRID (grid), h_scale, 0, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), v_scale, 1, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), hlabel, 0, 1, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), vlabel, 1, 1, 1, 1);
      
    
      gtk_container_add (GTK_CONTAINER (window), grid);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Toto je funkce zpětného volání
     * Jedná se o obslužnou funkci, která reaguje na signál 
     * V tomto případě upozorní uživatele na hodnotu na stupnici v podobě popisku
     */
    static void
    hscale_moved (GtkRange *range,
                  gpointer  user_data)
    {
       GtkWidget *label = user_data;
    
       /* Získá hodnotu z rozsahu a převede ji na řetězec, který bude
        * použit jako nový popisek pro vodorovnou stupnici
        * %.0f - maska pro typ double, který bude mít 0 desetinných míst
        */
       gdouble pos = gtk_range_get_value (range);
       /* Poznámka: g_strdup_printf vrací řetězec, který je třeba uvolnit
        * (což je uděláno dále)
        */
       gchar *str = g_strdup_printf ("Horizontal scale is %.0f", pos);
       gtk_label_set_text (GTK_LABEL (label), str);
    
       g_free(str);
    }
    
    
    
    /* Toto je druhá funkce zpětného volání. Jedná se o obslužnou funkci, která
     * reaguje na signál. Dělá stejnou věc, jako funkce výše, akorát pro svislou
     * stupnici
     */
    static void
    vscale_moved (GtkRange *range,
                  gpointer  user_data)
    {
       GtkWidget *label = user_data;
       
       gdouble pos = gtk_range_get_value (range);
       /* %.1f - maska pro typ double, který bude mít 1 desetinné místo */
       gchar *str = g_strdup_printf ("Vertical scale is %.1f", pos);
       gtk_label_set_text (GTK_LABEL (label), str);
    
       
       g_free (str);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      /* Deklarace proměnných */
      GtkWidget *window;
      GtkWidget *h_scale;
      GtkWidget *v_scale;
      GtkWidget *hlabel;
      GtkWidget *vlabel;
      GtkWidget *grid;
    
      /* Objekt Adjustment představující hodnoty, které
       * budou přiřazeny jako dolní a horní mez
       */
      GtkAdjustment *hadjustment;
      GtkAdjustment *vadjustment;
    
      /* Vytvoří okno s názvem do záhlaví a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Scale Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
      gtk_container_set_border_width (GTK_CONTAINER (window), 5);
    
      /* Dva popisky, které budou zobrazeny v okně */
      hlabel = gtk_label_new ("Move the scale handle...");
      vlabel = gtk_label_new ("Move the scale handle...");
    
       
      /* gtk_adjustment_new přebírá šest parametrů, tři z nich
       * mohou být složitější na pochopení:
       * přírůstek kroku- viditelný posun táhla při použití kurzorové šipky na klávesnici
       * přírůstek stránky - viditelný posun táhla při kliknutí mimo něj na stupnici
       * velikost stránky - zde nepoužito
       */
      hadjustment = gtk_adjustment_new (0, 0, 100, 5, 10, 0);
      vadjustment = gtk_adjustment_new (50, 0, 100, 5, 10, 0); 
    
      /* Vytvoří vodorovnou stupnici, zajistí že čísla nebudou mít žádná
       * desetinná místa
       */
      h_scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, hadjustment);
      gtk_scale_set_digits (GTK_SCALE (h_scale), 0); 
    
      /* Umožníme ji roztáhnout se vodorovně (pokud je místo) a
       * nastaví ji svislé zarovnání
       */
      gtk_widget_set_hexpand (h_scale, TRUE);
      gtk_widget_set_valign (h_scale, GTK_ALIGN_START);
      
      /* Napojí signál "value-changed" pro vodorovnou stupnici na
       * příslušnou funkci zpětného volání
       * Všimněte si, že GtkRange je součástí hierarchie objektů GtkScale
       */
      g_signal_connect (h_scale, 
                        "value-changed", 
                        G_CALLBACK (hscale_moved), 
                        hlabel);
    
    
    
      /* Vytvoří svislou stupnici. Tentokrát uvidíme, co se stane, když
       * čísla nejsou na začátku nastavena
       */
      v_scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, vadjustment);
      gtk_widget_set_vexpand (v_scale, TRUE);
    
      /* Napojí signál "value-changed" pro svislou stupnici na
       * příslušnou funkci zpětného volání
       */
      g_signal_connect (v_scale, 
                        "value-changed", 
                        G_CALLBACK (vscale_moved), 
                        vlabel);
    
      /* Vytvoří mřížku a vše do ní správně uspořádá */
      grid = gtk_grid_new ();
      gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
      gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE);
      gtk_grid_attach (GTK_GRID (grid), h_scale, 0, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), v_scale, 1, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), hlabel, 0, 1, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), vlabel, 1, 1, 1, 1);
      
    
      gtk_container_add (GTK_CONTAINER (window), grid);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/glib/stable/glib-String-Utility-Functions.html#g-strdup-printf">String Utility Functions</link>
cs: <link href="http://developer.gnome.org/glib/stable/glib-String-Utility-Functions.html#g-strdup-printf">Funkce pro práci s řetězci</link>

note: (itstool) path: info/desc
en: A slider which corresponds to a numerical value
cs: Stupnice, která odpovídá číselné hodnotě

note: (itstool) path: page/p
en: A Scale is a horizontal or vertical slider, that represents a value inside a numerical range. When you create a new Scale, you set what its default position is, what the numbers at the top and bottom of the range are, and things like how much it moves up or down when you click on the Scale to either side of the knob. To keep from having to type all that in every time you create a new Scale, you can create an object called an Adjustment which keeps track of all that, then tell each new Scale to use that Adjustment.
cs: Widget <code>Scale</code> (stupnice), je vodorovná nebo svislá lišta s táhlem, která představuje hodnotu z nějakého číselného rozsahu. Když vytvoříte novou stupnici, nastavíte ji výchozí polohu, která čísla odpovídají dolní a horní mezi rozsahu, a věci, jako o kolik se má posunout nahoru/dolů při kliknutí na konce lišty. Abyste nemuseli všechny tyto věci psát znovu a znovu, když stupnici vytváříte, můžete vytvořit objekt <code>Adjustment</code> (přizpůsobení), který si to vše pamatuje, a stupnici pak akorát řeknete, že ho má použít.

note: (itstool) path: page/p
en: This scale is a simple widget that lets you adjust the size of an iceberg that penguins live on. The number of penguins on the iceberg is the product of the values of the two sliders. Try playing with them and seeing what happens.
cs: Tato stupnice je jednoduchý widget, pomocí kterého můžeme upravovat velikost ledové kry, na které žijí tučňáci. Počet tučňáků na kře je násobkem hodnot ze dvou stupnic. Hrajte si s nimi a uvidíte, co se bude dít.

note: (itstool) path: section/code
en: 
    const ScaleExample = new Lang.Class({
        Name: 'Scale Example',
    
        // Create the application itself
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsscale'
            });
    
        // Connect 'activate' and 'startup' signals to the callback functions
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Callback function for 'activate' signal presents window when active
        _onActivate: function() {
            this._window.present();
        },
    
        // Callback function for 'startup' signal builds the UI
        _onStartup: function() {
            this._buildUI ();
        },
cs: 
    const ScaleExample = new Lang.Class({
        Name: 'Scale Example',
    
        // Vytvoří vlastní aplikaci
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsscale'
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate: function() {
            this._window.present();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function() {
            this._buildUI ();
        },

note: (itstool) path: section/p
en: All the code for this sample goes in the ScaleExample class. The above code creates a <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> for our widgets and window to go in.
cs: Všechen kód této ukázky je ve třídě ScaleExample. Výše uvedený kód vytvoří <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> pro naše widgety a okno, ve kterém budou.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI: function() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Birds on a Floe"});
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Birds on a Floe"});

note: (itstool) path: section/title
en: Creating the scales
cs: Vytvoření stupnic

note: (itstool) path: section/code
en: 
            // Create the horizontal scale
            this._hScale = Gtk.Scale.new_with_range (Gtk.Orientation.HORIZONTAL, 0.0, 100.0, 5.0);
            this._hScale.set_valign (Gtk.Align.START);
            this._hScale.set_value (50);
            this._hScale.set_digits (0);
            // this._hScale.set_draw_value (false);
cs: 
            // Vytvoří vodorovnou stupnici
            this._hScale = Gtk.Scale.new_with_range (Gtk.Orientation.HORIZONTAL, 0.0, 100.0, 5.0);
            this._hScale.set_valign (Gtk.Align.START);
            this._hScale.set_value (50);
            this._hScale.set_digits (0);
            // this._hScale.set_draw_value (false);

note: (itstool) path: section/p
en: The new_with_range method is one way to create a new Scale widget. The parameters it takes are a <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gtk.Orientation.html">Gtk.Orientation</link>, the minimum value, the maximum value, and the increment for a single step. After that we use the Scale's methods to set its starting value, and how many decimal places it runs to. We also set its vertical alignment in this case, to control where it appears in the window.
cs: Metoda <code>new_with_range</code> je jedním ze způsobů, jak vytvořit nový widget <code>Scale</code>. Přebírané parametry jsou <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gtk.Orientation.html">Gtk.Orientation</link>, nejnižší hodnota, nejvyšší hodnota a přírůstek pro jeden krok. Potom použijeme metody widgetu k nastavení jeho počáteční hodnoty a kolik desetinných míst má používat. V tomto případě také nastavíme svislé zarovnání, které určuje, kde v okně se objeví.

note: (itstool) path: section/p
en: We can use the set_draw_value method to tell it whether or not to show the number next to the sliding scale. It's commented out in this example.
cs: Můžeme použít metodu <code>set_draw_value</code>, abychom řekli, jestli se má nebo nemá vedle stupnice zobrazovat číselná hodnota. V tomto příkladu je zakomentováno.

note: (itstool) path: section/code
en: 
            // Create a master adjustment to use for the vertical (or any other) scale
            this._adjustment = new Gtk.Adjustment ({
                value: 95,
                lower: 0,
                upper: 100,
                step_increment: 5,
                page_increment: 10 });
cs: 
            // Vytvoří hlavní přizpůsobení, které se použije pro svislou (nebo jinou) stupnici
            this._adjustment = new Gtk.Adjustment ({
                value: 95,
                lower: 0,
                upper: 100,
                step_increment: 5,
                page_increment: 10 });

note: (itstool) path: section/p
en: An Adjustment is an object we can use to simplify things when creating a new Scale. The Adjustment's "value" property is what the Scale's default value is, while "upper" and "lower" make the high and low ends of the numerical range. Meanwhile, the increment values show how much the slider moves when you do things like click on it.
cs: Objekt <code>Adjustment</code> (přizpůsobení) můžete použít pro zjednodušení věcí okolo vytváření nové stupnice. Vlastnost <code>"value"</code> u přizpůsobení je to stejné, co výchozí hodnota u stupnice, zatímco <code>"upper"</code> a <code>"lower"</code> určují meze číselného rozsahu. Mezi tím jsou přírůstky hodnot říkající, jak moc se má posunout táhlo, když uděláte takové věci, jako že na stupnici kliknete.

note: (itstool) path: section/code
en: 
            // Create a vertical scale using the adjustment we just made
            this._vScale = new Gtk.Scale ({
                orientation: Gtk.Orientation.VERTICAL,
                adjustment: this._adjustment,
                digits: 0,
                // draw_value: false,
                margin_left: 10 });
cs: 
            // Vytvoří svislou stupnici používající přizpůsobení, 
            // které jsme právě vytvořili
            this._vScale = new Gtk.Scale ({
                orientation: Gtk.Orientation.VERTICAL,
                adjustment: this._adjustment,
                digits: 0,
                // draw_value: false,
                margin_left: 10 });

note: (itstool) path: section/p
en: Here we create a new Scale object using _adjustment as its "adjustment" property. This is a great shortcut. We still have to tell it to round off the decimal place, though. Note that the draw_value property is commented out; this is how you tell it not to show the number next to the Scale when you're creating one this way.
cs: Zde vytvoříme novou stupnici pomocí přiřazení <code>_adjustment</code> do její vlastnosti <code>"adjustment"</code>. Jedná se o velkou zkratku, i když i tak pořád musíme stupnici říct, na kolik desetinných míst má fungovat. Poznamenejme, že vlastnost <code>"draw_value"</code> je zakomentovaná. Jedná se o způsob, jak říct, že se nemá vedle stupnice zobrazovat číselná hodnota, když stupnici vytváříte tímto způsobem.

note: (itstool) path: section/code
en: 
            // Create the label that shows the product of the two values
            this._product = (this._hScale.get_value() * this._vScale.get_value());
            this._label = new Gtk.Label ({
                label: (String(this._product) + " penguins on the iceberg."),
                height_request: 200,
                width_request: 200,
                wrap: true});
    
            // Connect the two scales to functions which recalculate the label
            this._hScale.connect ("value-changed", Lang.bind (this, this._recalc));
            this._vScale.connect ("value-changed", Lang.bind (this, this._recalc));
cs: 
            // Vytvoří popisek, který zobrazuje součin dvou hodnot
            this._product = (this._hScale.get_value() * this._vScale.get_value());
            this._label = new Gtk.Label ({
                label: (String(this._product) + " penguins on the iceberg."),
                height_request: 200,
                width_request: 200,
                wrap: true});
    
            // Napojí dvě stupnice na funkci, která přepočítává údaj pro popisek
            this._hScale.connect ("value-changed", Lang.bind (this, this._recalc));
            this._vScale.connect ("value-changed", Lang.bind (this, this._recalc));

note: (itstool) path: section/p
en: We can use the get_value method to find out the numerical value a Scale is set at. We can then do whatever we want with it, including multiply the two Scales' values together and have a <link xref="label.js">Label</link> show us the product. We set the label's text to wrap around, because we're having it display a silly message too.
cs: Můžeme použít metodu <code>get_value_method</code> k nalezení číselné hodnoty, na kterou je stupnice nastavena. S ní pak můžeme dělat cokoliv je potřeba, včetně vzájemného vynásobení hodnot ze dvou stupnic. Součin pak zobrazíme ve widgetu <link xref="label.js">Label</link>. Nastavíme, aby se text popisku zalamovat, protože bude rovněž zobrazovat bláznivou zprávu.

note: (itstool) path: section/p
en: After we create the Label, we connect the two Scales' "value-changed" signals to _recalc, a function that will recalculate the number of penguins on the iceberg and come up with a new message.
cs: Když máme vytvořený popisek, napojíme signály <code>"value-changed"</code> od obou stupnic na funkci <code>_recals</code>, která bude přepočítávat počet tučňáků na ledové kře a podávat o nich novou zprávu.

note: (itstool) path: section/code
en: 
            // Create a grid to arrange things in
            this._UIGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_top: 20,
                margin_left: 20});
    
            // Attach everything to the grid
            this._UIGrid.attach (this._label, 0, 0, 1, 1);
            this._UIGrid.attach (this._hScale, 0, 1, 1, 1);
            this._UIGrid.attach (this._vScale, 1, 0, 1, 1);
cs: 
            // Vytvoří mřížku pro uspořádání věcí
            this._UIGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_top: 20,
                margin_left: 20});
    
            // Připojí vše do mřížky
            this._UIGrid.attach (this._label, 0, 0, 1, 1);
            this._UIGrid.attach (this._hScale, 0, 1, 1, 1);
            this._UIGrid.attach (this._vScale, 1, 0, 1, 1);

note: (itstool) path: section/p
en: Here we create a <link xref="grid.js">Grid</link> to put everything in, then attach all our widgets to it. Note that here and on some of the widgets themselves we're using margins to keep things neatly spaced.
cs: Zde pro všechno vytvoříme widget <link xref="grid.js">Grid</link> a všechny naše widgety do něj připojíme. Všimněte si, že zde (a i u některých widgetů) použijeme okraje, abychom zachovali potřebné rozestupy.

note: (itstool) path: section/code
en: 
            // Add the grid to the window
            this._window.add (this._UIGrid);
    
            // Show the window and all child widgets
            this._window.show_all();
        },
cs: 
            // Přidá mřížku do okna
            this._window.add (this._UIGrid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        },

note: (itstool) path: section/p
en: Finally, we add the Grid to the window, then tell the window to show itself and all the widgets inside of it.
cs: Nakonec přidáme mřížku do okna a následně oknu řekneme, aby zobrazilo sebe a všechny widgety uvnitř sebe.

note: (itstool) path: section/title
en: Function which handles the scales' values changing
cs: Funkce, která obsluhuje změnu hodnoty na stupnici

note: (itstool) path: section/code
en: 
        _recalc: function() {
    
            // Figure out what the product of the two scales' values is
            var product = (this._hScale.get_value() * this._vScale.get_value());
    
            // Create a blank comment line in case there isn't a silly comment to make
            var comment = "";
    
            // Make a silly comment based on the number of penguins
            if (product &gt; 9000) {
                comment = "It's over 9000!";
            }
            else if (product &lt; 1000 &amp;&amp; product &gt; 0) {
                comment = "They're getting lonely.";
            }
            else if (product == 0) {
                comment = "They're all gone ...";
            }
            else comment = "";
    
            // Set ._label's new text
            this._label.set_label (String (product) + " penguins on the iceberg. " + comment);
    
        }
    
    });
cs: 
        _recalc: function() {
    
            // Zjistí, jaký je součin hodnot ze dvou stupnic
            var product = (this._hScale.get_value() * this._vScale.get_value());
    
            // Vytvoří prázdný komentář pro případ, kdy není jaký bláznivý komentář vytvořit
            var comment = "";
    
            // Vytvoří bláznivý komentář vycházející z počtu tučňáků
            if (product &gt; 9000) {
                comment = "It's over 9000!";
            }
            else if (product &lt; 1000 &amp;&amp; product &gt; 0) {
                comment = "They're getting lonely.";
            }
            else if (product == 0) {
                comment = "They're all gone…";
            }
            else comment = "";
    
            // Nastaví nový text pro ._label
            this._label.set_label (String (product) + " penguins on the iceberg. " + comment);
    
        }
    
    });

note: (itstool) path: section/p
en: Remember, we can get a Scale's value using its get_value method. Here we simply recalculate what the product of the two values is after one of the Scales is moved, add in a silly message depending on how many penguins are left, and change the wording on _label to show the new number and message.
cs: Pamatujete, jak jsme od stupnice získali hodnotu pomocí její metody <code>get_value</code>? Zde jednoduše přepočítáme součin dvou hodnot po té, co je stupnice posunuta, přidáme bláznivou zprávu v závislosti na tom, kolik tučňáků zůstalo, a změníme formulaci v <code>_label</code> ukazujícím nový počet a zprávu.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new ScaleExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new ScaleExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished ScaleExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci konečné třídy ScaleExample a aplikaci spustíme.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class ScaleExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsscale'
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Birds on a Floe"});
    
            // Create the horizontal scale
            this._hScale = Gtk.Scale.new_with_range (Gtk.Orientation.HORIZONTAL, 0.0, 100.0, 5.0);
            this._hScale.set_valign (Gtk.Align.START);
            this._hScale.set_value (50);
            this._hScale.set_digits (0);
            // this._hScale.set_draw_value (false);
    
            // Create a master adjustment to use for the vertical (or any other) scale
            this._adjustment = new Gtk.Adjustment ({
                value: 95,
                lower: 0,
                upper: 100,
                step_increment: 5,
                page_increment: 10 });
    
            // Create a vertical scale using the adjustment we just made
            this._vScale = new Gtk.Scale ({
                orientation: Gtk.Orientation.VERTICAL,
                adjustment: this._adjustment,
                digits: 0,
                // draw_value: false,
                margin_left: 10 });
    
            // Create the label that shows the product of the two values
            this._product = (this._hScale.get_value() * this._vScale.get_value());
            this._label = new Gtk.Label ({
                label: (String(this._product) + " penguins on the iceberg."),
                height_request: 200,
                width_request: 200,
                wrap: true});
    
            // Connect the two scales to functions which recalculate the label
            this._hScale.connect ("value-changed", this._recalc.bind(this));
            this._vScale.connect ("value-changed", this._recalc.bind(this));
    
            // Create a grid to arrange things in
            this._UIGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_top: 20,
                margin_left: 20});
    
            // Attach everything to the grid
            this._UIGrid.attach (this._label, 0, 0, 1, 1);
            this._UIGrid.attach (this._hScale, 0, 1, 1, 1);
            this._UIGrid.attach (this._vScale, 1, 0, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._UIGrid);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _recalc() {
    
            // Figure out what the product of the two scales' values is
            var product = (this._hScale.get_value() * this._vScale.get_value());
    
            // Create a blank comment line in case there isn't a silly comment to make
            var comment = "";
    
            // Make a silly comment based on the number of penguins
            if (product &gt; 9000) {
                comment = "It's over 9000!";
            }
            else if (product &lt; 1000 &amp;&amp; product &gt; 0) {
                comment = "They're getting lonely.";
            }
            else if (product == 0) {
                comment = "They're all gone ...";
            }
            else comment = "";
    
            // Set ._label's new text
            this._label.set_label (String (product) + " penguins on the iceberg. " + comment);
        }
    };
    
    // Run the application
    let app = new ScaleExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class ScaleExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsscale'
            });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Birds on a Floe"});
    
            // Vytvoří vodorovnou stupnici
            this._hScale = Gtk.Scale.new_with_range (Gtk.Orientation.HORIZONTAL, 0.0, 100.0, 5.0);
            this._hScale.set_valign (Gtk.Align.START);
            this._hScale.set_value (50);
            this._hScale.set_digits (0);
            // this._hScale.set_draw_value (false);
    
            // Vytvoří hlavní přizpůsobení, které se použije pro svislou (nebo jinou) stupnici
            this._adjustment = new Gtk.Adjustment ({
                value: 95,
                lower: 0,
                upper: 100,
                step_increment: 5,
                page_increment: 10 });
    
            // Vytvoří svislou stupnici používající přizpůsobení, 
            // které jsme právě vytvořili
            this._vScale = new Gtk.Scale ({
                orientation: Gtk.Orientation.VERTICAL,
                adjustment: this._adjustment,
                digits: 0,
                // draw_value: false,
                margin_left: 10 });
    
            // Vytvoří popisek, který zobrazuje součin dvou hodnot
            this._product = (this._hScale.get_value() * this._vScale.get_value());
            this._label = new Gtk.Label ({
                label: (String(this._product) + " penguins on the iceberg."),
                height_request: 200,
                width_request: 200,
                wrap: true});
    
            // Napojí dvě stupnice na funkci, která přepočítává údaj pro popisek
            this._hScale.connect ("value-changed", this._recalc.bind(this));
            this._vScale.connect ("value-changed", this._recalc.bind(this));
    
            // Vytvoří mřížku pro uspořádání věcí
            this._UIGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_top: 20,
                margin_left: 20});
    
            // Připojí vše do mřížky
            this._UIGrid.attach (this._label, 0, 0, 1, 1);
            this._UIGrid.attach (this._hScale, 0, 1, 1, 1);
            this._UIGrid.attach (this._vScale, 1, 0, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._UIGrid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _recalc() {
    
            // Zjistí, jaký je součin hodnot ze dvou stupnic
            var product = (this._hScale.get_value() * this._vScale.get_value());
    
            // Vytvoří prázdný komentář pro případ, kdy není jaký bláznivý komentář vytvořit
            var comment = "";
    
            // Vytvoří bláznivý komentář vycházející z počtu tučňáků
            if (product &gt; 9000) {
                comment = "It's over 9000!";
            }
            else if (product &lt; 1000 &amp;&amp; product &gt; 0) {
                comment = "They're getting lonely.";
            }
            else if (product == 0) {
                comment = "They're all gone ...";
            }
            else comment = "";
    
            // Nastaví nový text pro ._label
            this._label.set_label (String (product) + " penguins on the iceberg. " + comment);
        }
    };
    
    // Spustí aplikaci
    let app = new ScaleExample ();
    app.application.run (ARGV);

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Scale Example", application=app)
            self.set_default_size(400, 300)
            self.set_border_width(5)
    
            # two adjustments (initial value, min value, max value,
            # step increment - press cursor keys to see!,
            # page increment - click around the handle to see!,
            # page size - not used here)
            ad1 = Gtk.Adjustment(0, 0, 100, 5, 10, 0)
            ad2 = Gtk.Adjustment(50, 0, 100, 5, 10, 0)
    
            # an horizontal scale
            self.h_scale = Gtk.Scale(
                orientation=Gtk.Orientation.HORIZONTAL, adjustment=ad1)
            # of integers (no digits)
            self.h_scale.set_digits(0)
            # that can expand horizontally if there is space in the grid (see
            # below)
            self.h_scale.set_hexpand(True)
            # that is aligned at the top of the space allowed in the grid (see
            # below)
            self.h_scale.set_valign(Gtk.Align.START)
    
            # we connect the signal "value-changed" emitted by the scale with the callback
            # function scale_moved
            self.h_scale.connect("value-changed", self.scale_moved)
    
            # a vertical scale
            self.v_scale = Gtk.Scale(
                orientation=Gtk.Orientation.VERTICAL, adjustment=ad2)
            # that can expand vertically if there is space in the grid (see below)
            self.v_scale.set_vexpand(True)
    
            # we connect the signal "value-changed" emitted by the scale with the callback
            # function scale_moved
            self.v_scale.connect("value-changed", self.scale_moved)
    
            # a label
            self.label = Gtk.Label()
            self.label.set_text("Move the scale handles...")
    
            # a grid to attach the widgets
            grid = Gtk.Grid()
            grid.set_column_spacing(10)
            grid.set_column_homogeneous(True)
            grid.attach(self.h_scale, 0, 0, 1, 1)
            grid.attach_next_to(
                self.v_scale, self.h_scale, Gtk.PositionType.RIGHT, 1, 1)
            grid.attach(self.label, 0, 1, 2, 1)
    
            self.add(grid)
    
        # any signal from the scales is signaled to the label the text of which is
        # changed
        def scale_moved(self, event):
            self.label.set_text("Horizontal scale is " + str(int(self.h_scale.get_value())) +
                                "; vertical scale is " + str(self.v_scale.get_value()) + ".")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Scale Example", application=app)
            self.set_default_size(400, 300)
            self.set_border_width(5)
    
            # Dvě přizpůsobení (počáteční hodnota, min. hodnota, max. hodnota,
            # přírůstek kroku - viz zmáčknutí kláves,
            # přírůstek stránky - viz kliknutí mimo táhlo,
            # velikost stránky - zde nepoužito)
            ad1 = Gtk.Adjustment(0, 0, 100, 5, 10, 0)
            ad2 = Gtk.Adjustment(50, 0, 100, 5, 10, 0)
    
            # Vodorovná stupnice
            self.h_scale = Gtk.Scale(
                orientation=Gtk.Orientation.HORIZONTAL, adjustment=ad1)
            # S celými čísly (bez desetinných míst)
            self.h_scale.set_digits(0)
            # Může se vodorovně roztáhnout, když je v mřížce místo (viz dále)
            self.h_scale.set_hexpand(True)
            # Je zarovnaná k horní části místa vyhrazeného v mřížce (viz dále)
            self.h_scale.set_valign(Gtk.Align.START)
    
            # Napojí signál "value-changed" vyslaný stupnicí na funkci
            # zpětného volání scale_moved
            self.h_scale.connect("value-changed", self.scale_moved)
    
            # Svislá stupnice
            self.v_scale = Gtk.Scale(
                orientation=Gtk.Orientation.VERTICAL, adjustment=ad2)
            # Může se svisle roztáhnout, když je v mřížce místo (viz dále)
            self.v_scale.set_vexpand(True)
    
            # Napojí signál "value-changed" vyslaný stupnicí na funkci
            # zpětného volání scale_moved
            self.v_scale.connect("value-changed", self.scale_moved)
    
            # Popisek
            self.label = Gtk.Label()
            self.label.set_text("Move the scale handles...")
    
            # Mřížka pro připojení widgetů
            grid = Gtk.Grid()
            grid.set_column_spacing(10)
            grid.set_column_homogeneous(True)
            grid.attach(self.h_scale, 0, 0, 1, 1)
            grid.attach_next_to(
                self.v_scale, self.h_scale, Gtk.PositionType.RIGHT, 1, 1)
            grid.attach(self.label, 0, 1, 2, 1)
    
            self.add(grid)
    
        # Který koliv signál od stupnice říká popisku, že má změnit text
        def scale_moved(self, event):
            self.label.set_text("Horizontal scale is " + str(int(self.h_scale.get_value())) +
                                "; vertical scale is " + str(self.v_scale.get_value()) + ".")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Scale widget
cs: Užitečné metody pro widget Scale

note: (itstool) path: section/p
en: A Gtk.Adjustment is needed to construct the Gtk.Scale. This is the representation of a value with a lower and upper bound, together with step and page increments, and a page size, and it is constructed as <code>Gtk.Adjustment(value, lower, upper, step_increment, page_increment, page_size)</code> where the fields are of type <code>float</code>; <code>step_increment</code> is the increment/decrement that is obtained by using the cursor keys, <code>page_increment</code> the one that is obtained clicking on the scale itself. Note that <code>page_size</code> is not used in this case, it should be set to <code>0</code>.
cs: <code>Gtk.Adjustment</code> je zapotřebí k vytvoření <code>Gtk.Scale</code>. Představuje hodnoty se spodní a horní hranicí, spolu s přírůstkem kroku a stránky a velikostí stránky, a vytváří se pomocí <code>Gtk.Adjustment(hodnota, spodní, horní, přírůstek_kroku, přírůstek_stránky, velikost_stránky)</code>, kde jednotlivé parametry jsou typu <code>float</code>. <code>přírůstek_kroku</code> určuje o kolik se má zvýšit/snížit hodnota při použití kurzorových kláves, <code>přírůstek_stránky</code> to stejné, ale při kliknutí na stupnici. Poznamenejme, že <code>velikost_stránky</code> zde nevyužíváme a měla by být nastavena na <code>0</code>.

note: (itstool) path: section/p
en: In line 28 the signal <code>"value-changed"</code> is connected to the callback function <code>scale_moved()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 28 je signál <code>"value-changed"</code> napojen na funkci zpětného volání <code>scale_moved()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: <code>get_value()</code> retrieves the current value of the scale; <code>set_value(value)</code> sets it (if the <code>value</code>, of type <code>float</code>, is outside the minimum or maximum range, it will be clamped to fit inside them). These are methods of the class Gtk.Range.
cs: <code>get_value()</code> získá aktuální hodnotu ze stupnice. <code>set_value(hodnota)</code> ji nastaví (pokud je <code>hodnota</code> typu <code>float</code> mimo rozsah minima a maxima, bude stažena tak, aby do něj zapadala). Toto jsou metody třídy Gtk.Range.

note: (itstool) path: item/p
en: Use <code>set_draw_value(False)</code> to avoid displaying the current value as a string next to the slider.
cs: Použití <code>set_draw_value(False)</code> zabrání zobrazování aktuální hodnoty v podobě řetězce vedle stupnice.

note: (itstool) path: item/p
en: To highlight the part of the scale between the origin and the current value:
cs: Když chcete zvýraznit část stupnice mezi počátkem a aktuální hodnotou:

note: (itstool) path: item/p
en: in the callback function of the "value-changed" signal, so to have the new filling every time the value is changed. These are methods of the class Gtk.Range.
cs: ve funkci zpětného volání pro signál <code>"value-changed"</code>, takže se znovu vyplní pokaždé, když se změní hodnota. Jedná se o metodu třídy Gtk.Range.

note: (itstool) path: item/p
en: <code>add_mark(value, position, markup)</code> adds a mark at the <code>value</code> (<code>float</code> or <code>int</code> if that is the precision of the scale), in <code>position</code> (<code>Gtk.PositionType.LEFT, Gtk.PositionType.RIGHT, Gtk.PositionType.TOP, Gtk.PositionType.BOTTOM</code>) with text <code>Null</code> or <code>markup</code> in the Pango Markup Language. To clear marks, <code>clear_marks()</code>.
cs: <code>add_mark(hodnota, pozice, značka)</code> přidá značku s <code>hodnotou</code> (<code>float</code> nebo <code>int</code>, pokud je stupnice s přesností na celá čísla) v místě <code>pozice</code> (<code>Gtk.PositionType.LEFT</code>, <code>Gtk.PositionType.RIGHT</code>, <code>Gtk.PositionType.TOP</code>, <code>Gtk.PositionType.BOTTOM</code>) s textem <code>Null</code> nebo <code>značka</code> ve značkovacím jazyce Pango. Ke smazání značek použijte <code>clear_marks()</code>.

note: (itstool) path: item/p
en: <code>set_digits(digits)</code> sets the precision of the scale at <code>digits</code> digits.
cs: <code>set_digits(číslic)</code> nastaví přesnost stupnice na zadaný počet <code>číslic</code>.

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/gtk3/unstable/gtk3-Standard-Enumerations.html">Standard Enumerations</link>
cs: <link href="http://developer.gnome.org/gtk3/unstable/gtk3-Standard-Enumerations.html">Standardní výčtové konstanty</link>

note: (itstool) path: page/code
en: /* This is the application. */
    public class MyApplication : Gtk.Application {
    	Gtk.Scale h_scale;
    	Gtk.Scale v_scale;
    	Gtk.Label label;
    
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "Scale Example";
    		window.set_default_size (400, 300);
    		window.set_border_width (5);
    
    		h_scale = new Gtk.Scale.with_range (Gtk.Orientation.HORIZONTAL, 0.0, 100.0, 5.0);
    		h_scale.set_digits (0); //number of decimal places displayed
    		h_scale.set_valign (Gtk.Align.START); //horizontal alignment
    
    		var adjustment = new Gtk.Adjustment (42.0, 0.0, 100.0, 5.0, 10.0, 0.0);
    		v_scale = new Gtk.Scale (Gtk.Orientation.VERTICAL, adjustment);
    		v_scale.set_vexpand(true);
    
    		label = new Gtk.Label ("Move the scale handles...");
    
    		var grid = new Gtk.Grid ();
    		grid.set_column_spacing (10); //amount of space between columns
    		grid.set_column_homogeneous (true); //all columns same width
    		grid.attach (h_scale, 0, 0, 1, 1);
    		grid.attach_next_to (v_scale, h_scale, Gtk.PositionType.RIGHT, 1, 1);
    		grid.attach (label, 0, 1, 2, 1);
    
    		h_scale.value_changed.connect (scale_moved);
    		v_scale.value_changed.connect (scale_moved);
    
    		window.add (grid);
    		window.show_all ();
    	}
    
    	/* Callback function for "value-changed" signal.
    	 * The parameter refers to the scale which emitted the signal.
    	 * Since we are accessing the values of not one, but two scales,
    	 * we made the ranges instance variables, and ignore the
    	 * parameter.
    	 */
    	void scale_moved (Gtk.Range range) {
    		label.set_text ("Horizontal scale is %.1f; vertical scale is %.1f.".printf (h_scale.get_value (), v_scale.get_value ()));
    	}
    }
    
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Toto je aplikace. */
    public class MyApplication : Gtk.Application {
    	Gtk.Scale h_scale;
    	Gtk.Scale v_scale;
    	Gtk.Label label;
    
    	/* Přepíše signál "activate" z GLib.Application. */
    	protected override void activate () {
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "Scale Example";
    		window.set_default_size (400, 300);
    		window.set_border_width (5);
    
    		h_scale = new Gtk.Scale.with_range (Gtk.Orientation.HORIZONTAL, 0.0, 100.0, 5.0);
    		h_scale.set_digits (0); //number of decimal places displayed
    		h_scale.set_valign (Gtk.Align.START); //horizontal alignment
    
    		var adjustment = new Gtk.Adjustment (42.0, 0.0, 100.0, 5.0, 10.0, 0.0);
    		v_scale = new Gtk.Scale (Gtk.Orientation.VERTICAL, adjustment);
    		v_scale.set_vexpand(true);
    
    		label = new Gtk.Label ("Move the scale handles...");
    
    		var grid = new Gtk.Grid ();
    		grid.set_column_spacing (10); //amount of space between columns
    		grid.set_column_homogeneous (true); //all columns same width
    		grid.attach (h_scale, 0, 0, 1, 1);
    		grid.attach_next_to (v_scale, h_scale, Gtk.PositionType.RIGHT, 1, 1);
    		grid.attach (label, 0, 1, 2, 1);
    
    		h_scale.value_changed.connect (scale_moved);
    		v_scale.value_changed.connect (scale_moved);
    
    		window.add (grid);
    		window.show_all ();
    	}
    
    	/* Funkce zpětného volání pro signál "value-changed".
    	 * Parametr odkazuje na stupnici, která signál vyslala.
    	 * Protože přistupujeme k hodnotě ne jedné, ale dvou stupnic,
    	 * vytvoříme proměnné s instancemi rozsahů a parametr budeme
    	 * ignorovat.
    	 */
    	void scale_moved (Gtk.Range range) {
    		label.set_text ("Horizontal scale is %.1f; vertical scale is %.1f.".printf (h_scale.get_value (), v_scale.get_value ()));
    	}
    }
    
    /* main vytvoří a spustí aplikaci. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: Adds scrollbars to its child widget
cs: Přidává posuvníky pro svůj synovský widget

note: (itstool) path: page/p
en: An image in a scrolled window.
cs: Obrázek v okně s posuvníky.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      /* Declare variables */
      GtkWidget *window;
      GtkWidget *scrolled_window;
      GtkWidget *image;
    
      /* Create a window with a title, and a default size */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "ScrolledWindow Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 220, 200);
    
      /* Create the scrolled window. Usually NULL is passed for both parameters so
       * that it creates the horizontal/vertical adjustments automatically. Setting
       * the scrollbar policy to automatic allows the scrollbars to only show up
       * when needed.
       */
      scrolled_window = gtk_scrolled_window_new (NULL, NULL);
      /* Set the border width */
      gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
      /* Extract our desired image from a file that we have */
      image = gtk_image_new_from_file ("gnome-image.png");
      /* And add it to the scrolled window */
      gtk_container_add (GTK_CONTAINER (scrolled_window), image);
      /* Set the policy of the horizontal and vertical scrollbars to automatic.
       * What this means is that the scrollbars are only present if needed.
       */
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
                                      GTK_POLICY_AUTOMATIC,
                                      GTK_POLICY_AUTOMATIC);
    
      gtk_container_add (GTK_CONTAINER (window), scrolled_window);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      /* Deklarace proměnných */
      GtkWidget *window;
      GtkWidget *scrolled_window;
      GtkWidget *image;
    
      /* Vytvoří okno s názvem, šířkou okraje a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "ScrolledWindow Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 220, 200);
    
      /* Vytvoří okno s posuvníky. Obvykle se oboum parametrům předává NULL, takže
       * se vodorovný i svislý posuvník vytvoří automaticky podle potřeby. Nastavení
       * pravidel posuvníků na automatiku umožní, aby se zobrazovaly jen když jsou
       * zapotřebí.
       */
      scrolled_window = gtk_scrolled_window_new (NULL, NULL);
      /* Nastaví šířku okraje */
      gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
      /* Získá ze souboru námi požadovaný obrázek */
      image = gtk_image_new_from_file ("gnome-image.png");
      /* A přidá jej do okna s posuvníky */
      gtk_container_add (GTK_CONTAINER (scrolled_window), image);
      /* Nastaví pravidlo pro vodorovný a svislý posuvník na automatiku.
       * Což znamená, že se posuvníky zobrazí, jen když je zapotřebí.
       */
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
                                      GTK_POLICY_AUTOMATIC,
                                      GTK_POLICY_AUTOMATIC);
    
      gtk_container_add (GTK_CONTAINER (window), scrolled_window);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const GObject = imports.gi.GObject;
    const Gtk = imports.gi.Gtk;
    
    class ScrolledWindowExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jscrolledwindow'
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this.window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
            // Create the application window
            this.window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "ScrolledWindow Example",
                default_width: 200,
                default_height: 200,
                border_width: 10
            });
            // the scrolledwindow
            this.scrolledWindow = new Gtk.ScrolledWindow();
            this.scrolledWindow.set_border_width(10);
            // there is always the scrollbar (otherwise: AUTOMATIC - only if needed - or NEVER)
            this.scrolledWindow.set_policy(Gtk.PolicyType.ALWAYS, Gtk.PolicyType.ALWAYS);
            // an image - slightly larger than the window
            this.image = new Gtk.Image();
            this.image.set_from_file("gnome-image.png");
    
            // add the image to the scrolledwindow
            this.scrolledWindow.add_with_viewport(this.image);
    
            // add the scrolledwindow to the window
            this.window.add(this.scrolledWindow);
            this.window.show_all();
        }
    };
    
    // Run the application
    let app = new ScrolledWindowExample();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const GObject = imports.gi.GObject;
    const Gtk = imports.gi.Gtk;
    
    class ScrolledWindowExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jscrolledwindow'
            });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this.window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
            // Vytvoří okno aplikace
            this.window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "ScrolledWindow Example",
                default_width: 200,
                default_height: 200,
                border_width: 10
            });
            // Okno s posuvníky
            this.scrolledWindow = new Gtk.ScrolledWindow();
            this.scrolledWindow.set_border_width(10);
            // Zde jsou posuvníky vždy (jinak: AUTOMATIC - podle potřeby, nebo NEVER - nikdy)
            this.scrolledWindow.set_policy(Gtk.PolicyType.ALWAYS, Gtk.PolicyType.ALWAYS);
            // Obrázek - lehce větší než okno
            this.image = new Gtk.Image();
            this.image.set_from_file("gnome-image.png");
    
            // Přidá obrázek do okna s posuvníky
            this.scrolledWindow.add_with_viewport(this.image);
    
            // Přidá okno s posuvníky do okna
            this.window.add(this.scrolledWindow);
            this.window.show_all();
        }
    };
    
    // Spustí aplikaci
    let app = new ScrolledWindowExample();
    app.application.run (ARGV);

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(
                self, title="ScrolledWindow Example", application=app)
            self.set_default_size(200, 200)
    
            # the scrolledwindow
            scrolled_window = Gtk.ScrolledWindow()
            scrolled_window.set_border_width(10)
            # there is always the scrollbar (otherwise: AUTOMATIC - only if needed
            # - or NEVER)
            scrolled_window.set_policy(
                Gtk.PolicyType.ALWAYS, Gtk.PolicyType.ALWAYS)
    
            # an image - slightly larger than the window...
            image = Gtk.Image()
            image.set_from_file("gnome-image.png")
    
            # add the image to the scrolledwindow
            scrolled_window.add_with_viewport(image)
    
            # add the scrolledwindow to the window
            self.add(scrolled_window)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(
                self, title="ScrolledWindow Example", application=app)
            self.set_default_size(200, 200)
    
            # Okno s posuvníky
            scrolled_window = Gtk.ScrolledWindow()
            scrolled_window.set_border_width(10)
            # Zde jsou posuvníky vždy (jinak: AUTOMATIC - podle potřeby, 
            # nebo NEVER - nikdy)
            scrolled_window.set_policy(
                Gtk.PolicyType.ALWAYS, Gtk.PolicyType.ALWAYS)
    
            # Obrázek - lehce větší než okno
            image = Gtk.Image()
            image.set_from_file("gnome-image.png")
    
            # Přidá obrázek do okna s posuvníky
            scrolled_window.add_with_viewport(image)
    
            # Přidá okno s posuvníky do okna
            self.add(scrolled_window)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a ScrolledWindow widget
cs: Užitečné metody pro widget ScrolledWindow

note: (itstool) path: item/p
en: <code>set_policy(hscrollbar_policy, vscrollbar_policy)</code> where each of the arguments is one of <code>Gtk.Policy.AUTOMATIC, Gtk.Policy.ALWAYS, Gtk.Policy.NEVER</code> regulates whether the horizontal and vertical scrollbars should appear: with <code>AUTOMATIC</code> they appear only if needed, <code>ALWAYS</code> and <code>NEVER</code> are self-explanatory.
cs: <code>set_policy(pravidlo_vodorovného_posuvníku, pravidlo_svislého posuvníku)</code>, kde oba parametry jsou něco z <code>Gtk.Policy.AUTOMATIC, Gtk.Policy.ALWAYS, Gtk.Policy.NEVER</code> reguluje, kdy by se měl vodorovný a svislý posuvník zobrazit: s <code>AUTOMATIC</code> se zobrazí v případě potřeby, s <code>ALWAYS</code> vždy a s <code>NEVER</code> nikdy.

note: (itstool) path: item/p
en: <code>add_with_viewport(widget)</code> is used to add the Gtk.Widget <code>widget</code> without native scrolling capabilities inside the window.
cs: <code>add_with_viewport(widget)</code> se používá k přidání <code>widgetu</code> (potomka <code>Gtk.Widget</code>) bez přirozené schopnosti posouvání svého obsahu.

note: (itstool) path: item/p
en: <code>set_placement(window_placement)</code> sets the placement of the contents with respect to the scrollbars for the scrolled window. The options for the argument are <code>Gtk.CornerType.TOP_LEFT</code> (default: the scrollbars are on the bottom and on the right of the window), <code>Gtk.CornerType.TOP_RIGHT, Gtk.CornerType.BOTTOM_LEFT, Gtk.CornerType.BOTTOM_RIGHT</code>.
cs: <code>set_placement(umisteni_okna)</code> nastavuje umístění obsahu vůči posuvníkům v okně s posuvníky. Možnosti argumentu jsou <code>Gtk.CornerType.TOP_LEFT</code> (výchozí: posuvníky jsou u spodního a pravého okraje okna), <code>Gtk.CornerType.TOP_RIGHT</code>, <code>Gtk.CornerType.BOTTOM_LEFT</code>, <code>Gtk.CornerType.BOTTOM_RIGHT</code>.

note: (itstool) path: item/p
en: <code>set_hadjustment(adjustment)</code> and <code>set_vadjustment(adjustment)</code> set the Gtk.Adjustment <code>adjustment</code>. This is the representation of a value with a lower and upper bound, together with step and page increments, and a page size, and it is constructed as <code>Gtk.Adjustment(value, lower, upper, step_increment, page_increment, page_size)</code> where the fields are of type <code>float</code>. (Note that <code>step_increment</code> is not used in this case, it can be set to <code>0</code>.)
cs: <code>set_hadjustment(přizpůsobení)</code> a <code>set_vadjustment(přizpůsobení)</code> nastaví <code>přizpůsobení</code> typu <code>Gtk.Adjustment</code>. Jedná se o reprezentaci hodnoty se spodní a horní mezí, spolu s přírůstkem kroku a stránky a s velikostí stránky. Vytvoří se jako <code>Gtk.Adjustment(hodnota, spodní_mez, horní_mez, přírůstek_kroku, přírůstek_stránky, velikost_stránky)</code>, kde všechny údaje jsou typu <code>float</code>. (Poznamenejme, že v tomto případě není <code>přírůstek_kroku</code> použit, takže může být nastaven na <code>0</code>.)

note: (itstool) path: page/code
en: /* This is the application. */
    public class MyApplication : Gtk.Application {
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    		/* Create the window of this application. */
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "ScrolledWindow Example";
    		window.set_default_size (200, 200);
    
    		var scrolled_window = new Gtk.ScrolledWindow (null, null);
    		scrolled_window.set_border_width (10);
    		scrolled_window.add_with_viewport (new Gtk.Image.from_file ("gnome-image.png"));
    		scrolled_window.set_policy (Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
    
    		window.add (scrolled_window);
    		window.show_all ();
    	}
    }
    
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Toto je aplikace. */
    public class MyApplication : Gtk.Application {
    	/* Přepíše signál "activate" z GLib.Application. */
    	protected override void activate () {
    		/* Vytvoří okno této aplikace. */
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "ScrolledWindow Example";
    		window.set_default_size (200, 200);
    
    		var scrolled_window = new Gtk.ScrolledWindow (null, null);
    		scrolled_window.set_border_width (10);
    		scrolled_window.add_with_viewport (new Gtk.Image.from_file ("gnome-image.png"));
    		scrolled_window.set_policy (Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
    
    		window.add (scrolled_window);
    		window.show_all ();
    	}
    }
    
    /* main vytvoří a spustí aplikaci. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: A separator widget
cs: Oddělovací widget

note: (itstool) path: page/p
en: A horizontal and a vertical separator divide some labels.
cs: Vodorovný a svislý oddělovač rozdělující pár popisků.

note: (itstool) path: section/title
en: API Reference
cs: Odkazy k API

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Separator Example", application=app)
    
            # three labels
            label1 = Gtk.Label()
            label1.set_text("Below, a horizontal separator.")
    
            label2 = Gtk.Label()
            label2.set_text("On the right, a vertical separator.")
    
            label3 = Gtk.Label()
            label3.set_text("On the left, a vertical separator.")
    
            # a horizontal separator
            hseparator = Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL)
            # a vertical separator
            vseparator = Gtk.Separator(orientation=Gtk.Orientation.VERTICAL)
    
            # a grid to attach labels and separators
            grid = Gtk.Grid()
            grid.attach(label1, 0, 0, 3, 1)
            grid.attach(hseparator, 0, 1, 3, 1)
            grid.attach(label2, 0, 2, 1, 1)
            grid.attach(vseparator, 1, 2, 1, 1)
            grid.attach(label3, 2, 2, 1, 1)
            grid.set_column_homogeneous(True)
            # add the grid to the window
            self.add(grid)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Separator Example", application=app)
    
            # Popisky stromu
            label1 = Gtk.Label()
            label1.set_text("Below, a horizontal separator.")
    
            label2 = Gtk.Label()
            label2.set_text("On the right, a vertical separator.")
    
            label3 = Gtk.Label()
            label3.set_text("On the left, a vertical separator.")
    
            # Vodorovný oddělovač
            hseparator = Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL)
            # Svislý oddělovač
            vseparator = Gtk.Separator(orientation=Gtk.Orientation.VERTICAL)
    
            # Mřížka pro připojení popisků a oddělovačů
            grid = Gtk.Grid()
            grid.attach(label1, 0, 0, 3, 1)
            grid.attach(hseparator, 0, 1, 3, 1)
            grid.attach(label2, 0, 2, 1, 1)
            grid.attach(vseparator, 1, 2, 1, 1)
            grid.attach(label3, 2, 2, 1, 1)
            grid.set_column_homogeneous(True)
            # Přidání mřížky do okna
            self.add(grid)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/code
en: /* This is the application. */
    public class Application : Gtk.Application {
    
    	public Application () {
    		Object (application_id: "org.example.window");
    	}
    
    	/* Override the 'activate' signal of GLib.Application,
    	 * which is inherited by Gtk.Application. */
    	public override void activate () {
    
    		var window = new Gtk.Window ();
    		window.title = "Separator Example";
    
    		var label1 = new Gtk.Label ("Below, a horizontal separator.");
    		var label2 = new Gtk.Label ("On the right, a vertical separator.");
    		var label3 = new Gtk.Label ("On the left, a vertical separator.");
    
    		var hseparator = new Gtk.Separator (Gtk.Orientation.HORIZONTAL);
    		var vseparator = new Gtk.Separator (Gtk.Orientation.VERTICAL);
    
    		var grid = new Gtk.Grid();
    
    		grid.attach (label1, 0, 0, 3, 1);
    		grid.attach (hseparator, 0, 1, 3, 1);
    		grid.attach (label2, 0, 2, 1, 1);
    		grid.attach (vseparator, 1, 2, 1, 1);
    		grid.attach (label3, 2, 2, 1, 1);
    
    		grid.set_column_homogeneous(true);
    
    		window.add (grid);
    		this.add_window (window);
    
    		window.show_all ();
    	}
    }
    
    /* The main function creates the application and runs it.*/
    int main (string[] args) {
    	var app = new Application ();
    	return app.run (args);
    }
cs: /* Toto je aplikace. */
    public class Application : Gtk.Application {
    
    	public Application () {
    		Object (application_id: "org.example.window");
    	}
    
    	/* Přepíše signál "activate" z GLib.Application, 
    	 * která je zděděná z Gtk.Application. */
    	public override void activate () {
    
    		var window = new Gtk.Window ();
    		window.title = "Separator Example";
    
    		var label1 = new Gtk.Label ("Below, a horizontal separator.");
    		var label2 = new Gtk.Label ("On the right, a vertical separator.");
    		var label3 = new Gtk.Label ("On the left, a vertical separator.");
    
    		var hseparator = new Gtk.Separator (Gtk.Orientation.HORIZONTAL);
    		var vseparator = new Gtk.Separator (Gtk.Orientation.VERTICAL);
    
    		var grid = new Gtk.Grid();
    
    		grid.attach (label1, 0, 0, 3, 1);
    		grid.attach (hseparator, 0, 1, 3, 1);
    		grid.attach (label2, 0, 2, 1, 1);
    		grid.attach (vseparator, 1, 2, 1, 1);
    		grid.attach (label3, 2, 2, 1, 1);
    
    		grid.set_column_homogeneous(true);
    
    		window.add (grid);
    		this.add_window (window);
    
    		window.show_all ();
    	}
    }
    
    /* Funkce main vytvoří aplikaci a spustí ji.*/
    int main (string[] args) {
    	var app = new Application ();
    	return app.run (args);
    }

note: (itstool) path: page/title
en: Set up gedit for JavaScript development
cs: Jak nastavit editor gedit pro vývoj v jazyce JavaScript.

note: (itstool) path: page/p
en: This tutorial will show you how to set up <link href="https://wiki.gnome.org/Apps/Gedit">gedit</link>, GNOME's basic text editor, so that it has a handful of extra features which are useful for writing JavaScript code.
cs: V této lekci si ukážeme, jak nastavit <link href="https://wiki.gnome.org/Apps/Gedit">gedit</link>, což je základní textový editor v GNOME, tak, aby měl doplňkové funkce, které jsou užitečné pro psaní kódu v jazyce JavaScript.

note: (itstool) path: section/title
en: Making code clearer
cs: Zpřehlednění kódu

note: (itstool) path: section/p
en: Click on <gui>Edit</gui> in gedit's menu bar, then click on <gui>Preferences</gui>. You should see something like this:
cs: Klikněte v nabídkové liště editoru gedit na <gui>Upravit</gui> a potom na <gui>Předvolby</gui>. Mělo by se vám zobrazit něco takového:

note: (itstool) path: section/p
en: Here are the options you want to make sure are turned on.
cs: Zde je pár voleb, u kterých byste se měli ujistit, že jsou zapnuté.

note: (itstool) path: item/p
en: <gui>Display line numbers</gui> will help you compare the code you type in with the original, and make it easier to see which line is causing an error if there is a bug.
cs: <gui>Zobrazovat čísla řádků</gui> pomáhá při porovnávání kódu, který píšete, s originálem, a usnadňuje vyhledání řádku, který způsobuje chybu, když se nějaká objeví.

note: (itstool) path: item/p
en: <gui>Highlight current line</gui> makes it easier to see which line you're on, when you have to go back and forth a lot.
cs: <gui>Zvýrazňovat aktuální řádek</gui> usnadňuje sledování, na kterém řádku se nacházíte, když často přeskakujete tam a zpět.

note: (itstool) path: item/p
en: <gui>Highlight matching brackets</gui> helps you make sure you didn't leave out a bracket by accident.
cs: <gui>Zvýrazňovat odpovídající závorky</gui> pomáhá při kontrole, jestli jste neopomněli uzavřít závorku.

note: (itstool) path: section/title
en: Making editing easier
cs: Usnadnění úprav

note: (itstool) path: section/p
en: In gedit's <gui>Preferences</gui> dialog, click on the <gui>Editor</gui> tab. You should see something like this:
cs: V dialogovém okně <gui>Předvolby</gui> editoru gedit klikněte na kartu <gui>Editor</gui>. Měli byste vidět něco takového:

note: (itstool) path: section/p
en: Here, you want to have <gui>Enable automatic indentation</gui> turned on. This means that when you hit <key>Enter</key> the cursor stays indented as far as the last line was. This is extremely useful when writing JavaScript code, since it uses indentation to make it clearer which parts do what.
cs: Zde můžete mít chtít zapnutou volbu <gui>Povolit automatické odsazování</gui>. To znamená, že když zmáčknete <key>Enter</key>, kurzor zůstane odsazený stejně daleko jako na předchozím řádku. To je obzvláště užitečné při psaní kódu v jazyce JavaScript, protože ten používá odsazování ke zpřehlednění, co která část dělá.

note: (itstool) path: note/p
en: If you want to share code with other people who write GNOME JavaScript applications, you'll also want to set <gui>Tab width</gui> to 4 and turn on <gui>Insert spaces instead of tabs</gui>.
cs: Pokud hodláte kód sdílet s jinými lidmi, kteří píší aplikace v jazyce JavaScript pro GNOME, měli byste také nastavit <gui>Šířku tabulátoru</gui> na 4 a zapnout <gui>Vkládat mezery místo tabulátorů</gui>.

[ctx: text]
note: (itstool) path: info/title
en: Signals and callbacks (Python)
cs: Signály a zpětná volání (Python)

note: (itstool) path: info/desc
en: An explanation of signals and callbacks in GTK+.
cs: Vysvětlení signálů a zpětných volání v GTK+.

note: (itstool) path: page/title
en: Signals and callbacks
cs: Signály a zpětná volání

note: (itstool) path: section/p
en: Like most GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ sits in the main loop and waits for input. If the user performs some action - say, a mouse click - then the main loop "wakes up" and delivers an event to GTK+.
cs: Podobně jako jiné nástrojové sady GUI, i GTK+ používá událostmi řízený model programování. Když uživatel nic nedělá, hoví si GTK+ v hlavní smyčce a čeká na vstup. Když uživatel provede nějakou činnost – řekněme, že klikne myší – tak se hlavní smyčka „probudí“ a doručí událost do GTK+.

note: (itstool) path: section/p
en: When widgets receive an event, they frequently emit one or more signals. Signals notify your program that "something interesting happened" by invoking functions you have connected to the signal. Such functions are commonly known as callbacks. When your callbacks are invoked, you would typically take some action. After a callback finishes, GTK+ will return to the main loop and await more user input.
cs: Když událost obdrží widgety, nejčastěji vyšlou jeden nebo více signálů. Signály upozorní váš program, že „se něco zajímavého stalo“ tím, že vyvolají funkci, kterou jste na signál napojili. Tyto funkce jsou obecně známé jako zpětná volání. Jakmile je vaše zpětné volání vyvoláno, měli byste běžně něco udělat. Po dokončení zpětného volání se GTK+ vrátí do zpětné smyčky a čeká na další uživatelův vstup.

note: (itstool) path: section/p
en: A generic example is: <code>handler_id = widget.connect("event", callback, data)</code>. <code>widget</code> is an instance of a widget we created earlier. Next, the <code>event</code> we are interested in. Each widget has its own particular events which can occur. For instance, if you have a Gtk.Button you usually want to connect to the "clicked" event: this means that when the button is clicked, the signal is issued. Another example is the <code>notify::property</code> signal: whenever a <link xref="properties.py">property</link> is modified on a GObject, instead of just emitting the <code>notify</code> signal, GObject associates as a detail to this signal emission the name of the property modified. This allows clients who wish to be notified of changes to only one property to filter most events before receiving them. Thirdly, the callback argument is the name of the callback function, which contains the code which runs when signals of the specified type are issued. Finally, the optional data argument includes any data which should be passed when the signal is issued.
cs: Obecný příklad: <code>handler_id = widget.connect("událost", zpětné_volání, data)</code>. <code>widget</code> je instance widgetu, který jsme vytvořili dříve. Následuje <code>událost</code>, která nás zajímá. Každý widget má své vlastní konkrétní události, které u něj mohou nastat. Například, když máte <code>Gtk.Button</code>, obvykle chcete napojit událost <code>"clicked"</code>: to znamená, že když je na tlačítko kliknuto, vyšle se signál. Jiným příkladem je signál <code>notify::property</code>: kdykoliv je u <code>GObject</code> změněna <link xref="properties.py">vlastnost</link>, tak místo prostého vyslání signálu <code>notify</code>, přiřadí <code>GObject</code> tomuto signálu doplňující údaj v podobě názvu změněné vlastnosti. To umožňuje klientovi, který si přeje být upozorňován na změny jen u jedné vlastnosti, odfiltrovat většinu událostí dříve, než k němu dorazí. Zatřetí, argument <code>zpětné_volání</code> je název funkce zpětného volání, která obsahuje kód, co se má spustit při vyslání signálu zadaného typu. A nakonec, volitelný argument <code>data</code> obsahuje libovolná data, která by měla být předána při vyslání signálu.

note: (itstool) path: section/p
en: The function returns a number (the <code>handler_id</code>) that identifies this particular signal-callback pair. This number is required to disconnect from a signal such that the callback function will not be called during any future or currently ongoing emissions of the signal it has been connected to, as in <code>widget.disconnect(handler_id)</code>.
cs: Funkce vrací číslo (<code>handler_id</code>), které identifikuje tento konkrétní pár signál/zpětné volání. Toto číslo je požadováno při odpojení signálu v podobě <code>widget.disconnect(handler_id)</code>. Způsobí to, že takováto funkce zpětného volání již nebude nadále volána v budoucnu nebo při právě probíhajícím vysílání signálu, který byl na ni napojen.

note: (itstool) path: section/p
en: <link href="http://developer.gnome.org/gobject/stable/signal.html">Signals</link> in GObject documentation
cs: <link href="http://developer.gnome.org/gobject/stable/signal.html">Signály</link> v dokumentaci k GObject

note: (itstool) path: section/p
en: <link href="http://python-gtk-3-tutorial.readthedocs.org/en/latest/basics.html">Basics - Main loop and Signals</link> in Python GTK+ 3 Tutorial
cs: <link href="http://python-gtk-3-tutorial.readthedocs.org/en/latest/basics.html">Základy – Hlavní smyčka a signály</link> ve výuce GTK+ 3 v jazyce Python

note: (itstool) path: info/desc
en: Retrieve an integer or floating point number
cs: Získává od uživatele celé nebo desetinné číslo

note: (itstool) path: page/p
en: Choose a number, by entering it or by clicking on the -/+ buttons!
cs: Zvolte číslo tak, že jej napíšete nebo naklikáte tlačítky <gui>+</gui>/<gui>-</gui>!

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* This is the callback function. 
     * It is a handler function which reacts to the signal. 
     * In this case, it will notify the user the value of their spinbutton 
     * as a label.
     */
    static void
    spin_clicked (GtkSpinButton *spinbutton,
                  gpointer       user_data)
    {
       GtkWidget *label = user_data;
       gint value = gtk_spin_button_get_value_as_int (spinbutton);
    
       /* %d - Is used when printing integers.
        * Note: Using g_strdup_printf returns a string that must be freed. 
        * (In which is done below)
        */
       gchar *str = g_strdup_printf ("The number you selected is %d.", value);
       gtk_label_set_text (GTK_LABEL (label), str);
    
       g_free(str);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      /* Declare variables */
      GtkWidget *window;
      GtkWidget *label;
      GtkWidget *grid;
      GtkWidget *spin_button;
      GtkAdjustment *adjustment;
    
    
      /* Create a window with a title, a border width, and a default size */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "SpinButton Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 210, 70);
      gtk_container_set_border_width (GTK_CONTAINER (window), 5);
    
      /* Create a label to be shown in the window */
      label = gtk_label_new ("Choose a number");
    
      /* Create an adjustment representing an adjustable bounded value */
      adjustment = gtk_adjustment_new (0, 0, 100, 1, 0, 0);
    
    
      /* Create a spin button that is to be as wide as possible */
      spin_button = gtk_spin_button_new (adjustment, 1, 0);
      gtk_widget_set_hexpand (spin_button, TRUE);
      
      /* Connecting the "value-changed" signal for the spinbutton 
       * to the appropriate callback function. 
       */
      g_signal_connect (spin_button, 
                        "value-changed", 
                        G_CALLBACK (spin_clicked), 
                        label);
    
    
      /* Create a grid and arrange everything accordingly */
      grid = gtk_grid_new ();
      gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
      gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE);
      gtk_grid_attach (GTK_GRID (grid), spin_button, 0, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
      
    
      gtk_container_add (GTK_CONTAINER (window), grid);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Jedná se o funkci zpětného volání. 
     * Je to zpracující funkce, která raguje na signál.. 
     * V tomto případě oznámí uživateli hodnotu z číselníku v podobě popisku.
     */
    static void
    spin_clicked (GtkSpinButton *spinbutton,
                  gpointer       user_data)
    {
       GtkWidget *label = user_data;
       gint value = gtk_spin_button_get_value_as_int (spinbutton);
    
       /* %d – používá se při výpisu celých čísel.
        * Poznámka: Při použití g_strdup_printf je vrácen řetězec, který musí být 
        * uvolněn. (Což je uděláno dále.)
        */
       gchar *str = g_strdup_printf ("The number you selected is %d.", value);
       gtk_label_set_text (GTK_LABEL (label), str);
    
       g_free(str);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      /* Declare variables */
      GtkWidget *window;
      GtkWidget *label;
      GtkWidget *grid;
      GtkWidget *spin_button;
      GtkAdjustment *adjustment;
    
    
      /* Vytvoří okno s názvem, šířkou okraje a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "SpinButton Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 210, 70);
      gtk_container_set_border_width (GTK_CONTAINER (window), 5);
    
      /* Vytvoří popisek, který bude zobrazen v okně */
      label = gtk_label_new ("Choose a number");
    
      /* Vytvoří GtkAdjustment, který představuje přizpůsobení hraničním hodnotám */
      adjustment = gtk_adjustment_new (0, 0, 100, 1, 0, 0);
    
    
      /* Vytvoří číselník tak široký, jak je možné */
      spin_button = gtk_spin_button_new (adjustment, 1, 0);
      gtk_widget_set_hexpand (spin_button, TRUE);
      
      /* Napojí signál "value-changed" od SpinButton k příslušné
       * funkci zpětného volání. 
       */
      g_signal_connect (spin_button, 
                        "value-changed", 
                        G_CALLBACK (spin_clicked), 
                        label);
    
    
      /* Vytvoří mřížku a všechno do ní správně uspořádá */
      grid = gtk_grid_new ();
      gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
      gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE);
      gtk_grid_attach (GTK_GRID (grid), spin_button, 0, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
      
    
      gtk_container_add (GTK_CONTAINER (window), grid);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: info/desc
en: A number entry field that has + and - buttons
cs: Číselné vstupní pole, které má tlačítka + a -

note: (itstool) path: page/p
en: A SpinButton is not related to a <link xref="spinner.js">Spinner</link>. It's a text entry field which only accepts numbers, and which has plus and minus buttons to let you change the value without having to type anything in.
cs: SpinButton (číselník) nemá žádnou souvislost s widgetem <link xref="spinner.js">Spinner</link> (káča). Jedná se o textové vstupní pole, které přijímá jen čísla a má tlačítka plus a mínus, která umožňují měnit hodnout, aniž byste museli psát.

note: (itstool) path: page/p
en: It's best used when it's obvious that only a number can be entered into it. In this example, two SpinButtons are used for the number of kittens and number of cans of tuna to give them.
cs: Je nejlepší pro použití v situacích, kdy je potřeba zadávat čistě číselné hodnoty. V tomto příkladu jsou dva číselníky použity pro počet koček a počet tuňákových konzerv pro ně.

note: (itstool) path: section/code
en: 
    const SpinButtonExample = new Lang.Class({
        Name: 'SpinButton Example',
    
        // Create the application itself
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsspinbutton'
            });
    
        // Connect 'activate' and 'startup' signals to the callback functions
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Callback function for 'activate' signal presents window when active
        _onActivate: function() {
            this._window.present();
        },
    
        // Callback function for 'startup' signal builds the UI
        _onStartup: function() {
            this._buildUI ();
        },
cs: 
    const SpinButtonExample = new Lang.Class({
        Name: 'SpinButton Example',
    
        // Vytvoří vlastní aplikaci
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsspinbutton'
            });
    
        // Připojí signály "activate" a "startup" k funkcím zpětného volání
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate: function() {
            this._window.present();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function() {
            this._buildUI ();
        },

note: (itstool) path: section/p
en: All the code for this sample goes in the SpinButtonExample class. The above code creates a <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> for our widgets and window to go in.
cs: Všechen kód této ukázky je ve třídě <code>SpinButtonExample</code>. Výše uvedený kód vytvoří <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> pro naše widgety a okno, ve kterém budou.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI: function() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Kitten Feeder"});
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Kitten Feeder"});

note: (itstool) path: section/title
en: Creating the SpinButtons
cs: Vytvoření widgetů SpinButton

note: (itstool) path: section/code
en: 
            // Create the first spinbutton using a function
            this._kittens = Gtk.SpinButton.new_with_range (1, 9001, 1);
            this._kittens.connect ("value-changed", Lang.bind (this, this._newValue));
cs: 
            // Pomocí funkce vytvoří první číselník
            this._kittens = Gtk.SpinButton.new_with_range (1, 9001, 1);
            this._kittens.connect ("value-changed", Lang.bind (this, this._newValue));

note: (itstool) path: section/p
en: We can use the new_with_range function to create a new SpinButton quickly. Its first parameter is the SpinButton's starting value, its second is the maximum value, and its third is how much to increment it when the plus or minus buttons are pressed.
cs: K rychlému vytvoření číselníku můžeme použít funkci <code>new_with_range</code>. Prvním parametrem je počáteční hodnota číselníku, druhým maximální hodnota a třetím velikost kroku použitého při mačkání tlačítek plus nebo mínus.

note: (itstool) path: section/p
en: After we create the first SpinButton, we connect its value-changed signal to a function which handles what happens when the number inside either SpinButton changes.
cs: Po vytvoření prvního číselníku napojíme jeho signál "value-changed" k funkci, která zpracovává, co se má stát, když se číslo uvnitř číselníku změní.

note: (itstool) path: section/code
en: 
            // Create an adjustment to use for the second spinbutton
            this._adjustment = new Gtk.Adjustment ({
                value: 1,
                lower: 0,
                upper: 9001,
                step_increment: 1,
                page_increment: 10 });
    
            // Create the second spinbutton
            this._tuna = new Gtk.SpinButton ({ adjustment: this._adjustment });
            this._tuna.connect ("value-changed", Lang.bind (this, this._newValue));
    
            // this._tuna.set_digits (1);
            // this._tuna.set_wrap (true);
cs: 
            // Vytvoří přizpůsobení, které se použije pro druhý číselník
            this._adjustment = new Gtk.Adjustment ({
                value: 1,
                lower: 0,
                upper: 9001,
                step_increment: 1,
                page_increment: 10 });
    
            // Vytvoří druhý číselník
            this._tuna = new Gtk.SpinButton ({ adjustment: this._adjustment });
            this._tuna.connect ("value-changed", Lang.bind (this, this._newValue));
    
            // this._tuna.set_digits (1);
            // this._tuna.set_wrap (true);

note: (itstool) path: section/p
en: If you want more fine-grained control over a SpinButton, or want to create a bunch of SpinButtons which all use the same parameters, you can create an object called an <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gtk.Adjustment.html">Adjustment</link>. Then you can use that object as a new SpinButton's adjustment property, and it sets all the values at once. Afterwards, you can change all the SpinButtons which use that adjustment by changing the Adjustment object's properties.
cs: Jestli chcete jemnější kontrolu nad widgetem <code>SpinButton</code> nebo chcete vytvořit spoustu číselníků, které budou mít stejné parametry, můžete vytvořit objekt <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gtk.Adjustment.html">Adjustmen</link> (přizpůsobení). Pak můžete použít tento objekt jako vlastnost <code>adjustment</code> pro nový číselník a tím ji nastavit všechny vlastnosti naráz. Později můžete změnit všechny číselníky, které používají toto přizpůsobení naráz pouhou změnou některé vlastnosti objektu <code>Adjustment</code>.

note: (itstool) path: section/p
en: The commented-out lines here show things you can do to customize your SpinButton. You can set the number of digits which go after the decimal point, for example, or tell it to wrap the number around if it goes past the upper or lower bounds that you set.
cs: Řádky zde zakomentované ukazují věci, které si můžete u číselníků přizpůsobit. Můžete například nastavit počet číslic za desetinnou čárkou nebo říci, aby se při dosažení nastavené horní nebo dolní meze přešlo dokola na opačný konec.

note: (itstool) path: note/p
en: For the kitties' sake, please don't use set_digits to allow a decimal number of kittens.
cs: V zájmu zdraví koček nepoužívejte prosím metodu <code>set_digits</code>, která by umožnila necelé počty koček.

note: (itstool) path: section/title
en: Creating the rest of the UI
cs: Vytvoření zbytku uživatelského rozhraní

note: (itstool) path: section/code
en: 
            // Create the text labels to go with the spinbuttons
            this._startLabel = new Gtk.Label ({ label: "There are " });
            this._kittenLabel = new Gtk.Label ({ label: " kitten(s), and "});
            this._tunaLabel = new Gtk.Label ({ label: " can(s) of tuna."});
            this.perKitten = Math.floor((this._tuna.get_value() / this._kittens.get_value()));
            this._lastLabel = new Gtk.Label ({
                label: "That's " + this.perKitten + " can(s) of tuna per kitten." });
cs: 
            // Vytvoří textové popisky, které budou u číselníků
            this._startLabel = new Gtk.Label ({ label: "There are " });
            this._kittenLabel = new Gtk.Label ({ label: " kitten(s), and "});
            this._tunaLabel = new Gtk.Label ({ label: " can(s) of tuna."});
            this.perKitten = Math.floor((this._tuna.get_value() / this._kittens.get_value()));
            this._lastLabel = new Gtk.Label ({
                label: "That's " + this.perKitten + " can(s) of tuna per kitten." });

note: (itstool) path: section/p
en: We create each <link xref="label.js">Label</link> individually, and then string them together along with the SpinButtons. The last label needs to show the number of cans of tuna per kitten, so it has a variable in the middle, which corresponds to an equation that uses the SpinButtons' get_value functions to find out what they're set at. JavaScript's Math function's floor method is used to round the number of cans of tuna per kitten down to the nearest whole number.
cs: Každý widget <link xref="label.js">Label</link> vytvoříme samostatně a pak je spojíme dohromady s jednotlivými číselníky. Poslední popisek potřebujeme na zobrazování počtu konzerv tuňáka na kočku, takže má uprostřed proměnnou odpovídající výpočtu, který používá funkce <code>get_value</code> u číselníků k zjištění, co je v nich nastaveno. Funkce <code>floor</code> z objektu <code>Math</code> jazyka JavaScript se použije k zaokrouhlení počtu konzerv tuňáka na kočku na nejbližší nižší celé číslo.

note: (itstool) path: section/code
en: 
            // Create a grid to put the spinbuttons and their labels in
            this._spinGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_bottom: 20 });
    
            // Attach everything to the grid
            this._spinGrid.attach (this._startLabel, 0, 0, 1, 1);
            this._spinGrid.attach (this._kittens, 1, 0, 1, 1);
            this._spinGrid.attach (this._kittenLabel, 2, 0, 1, 1);
            this._spinGrid.attach (this._tuna, 3, 0, 1, 1);
            this._spinGrid.attach (this._tunaLabel, 4, 0, 1, 1);
    
            // Create a main grid to hold it and the last label
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Attach the smaller grid and the last label to the main grid
            this._mainGrid.attach (this._spinGrid, 0, 0, 1, 1);
            this._mainGrid.attach (this._lastLabel, 0, 1, 1, 1);
cs: 
            // Vytvoří mřížku pro vložení číselníků a jejich popisků
            this._spinGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_bottom: 20 });
    
            // Připojí vše do mřížky
            this._spinGrid.attach (this._startLabel, 0, 0, 1, 1);
            this._spinGrid.attach (this._kittens, 1, 0, 1, 1);
            this._spinGrid.attach (this._kittenLabel, 2, 0, 1, 1);
            this._spinGrid.attach (this._tuna, 3, 0, 1, 1);
            this._spinGrid.attach (this._tunaLabel, 4, 0, 1, 1);
    
            // Vytvoří hlavní mřížku, která bude obsahovat tu předchozí a poslední popisek
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Připojí menší mřížku a posledního popisek do hlavní mřížky
            this._mainGrid.attach (this._spinGrid, 0, 0, 1, 1);
            this._mainGrid.attach (this._lastLabel, 0, 1, 1, 1);

note: (itstool) path: section/p
en: Here we use <link xref="grid.js">Grid</link> widgets to keep everything organized. One Grid holds the labels and SpinButtons in order, while the next puts that Grid on top and the final Label on the bottom.
cs: Zde používáme widgety <link xref="grid.js">Grid</link>, které vše udržují správně rozložené. Jedna mřížka obsahuje ve správném pořadí popisky a číselníky, zatímco následující obsahuje na hoře ji a dole konečný popisek.

note: (itstool) path: section/p
en: There isn't a wrong way to organize things in Grids, so long as you like how it turns out. In this case, the top Grid has a margin on the bottom to keep it evenly spaced from the bottom Label, and the bottom Label is inside a separate Grid so it will be centered relative to the Labels and SpinButtons on the top.
cs: Rozhodně není špatný způsob, hrát si s uspořádáním věcí do mřížek tak dlouho, až získáte to, co si přejete. V tomto případě má horní mřížka dole okraj, aby se uchoval odstup od spodního popisku a spodní popisek je uvnitř další mřížky, aby byl vystředěn relativně vůči popiskům a číselníkům nahoře.

note: (itstool) path: section/code
en: 
            // Add the main grid to the window
            this._window.add (this._mainGrid);
    
            // Show the window and all child widgets
            this._window.show_all();
        },
cs: 
            // Přidá mřížku do okna
            this._window.add (this._mainGrid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        },

note: (itstool) path: section/p
en: Finally, we add the larger Grid to the window, then tell the window to show itself and all the widgets inside of it.
cs: Nakonec přidáme větší mřížku do okna a oknu řekneme, že má zobrazit sebe a všechny widgety uvnitř sebe.

note: (itstool) path: section/title
en: Function which handles the SpinButtons' numerical values being adjusted
cs: Funkce, která obsluhuje změny číselných hodnot widgetů SpinButton

note: (itstool) path: section/code
en: 
        _newValue: function () {
    
            // Update the label which shows how many cans there are per kitten
            this.perKitten = Math.floor((this._tuna.get_value() / this._kittens.get_value()))
            this._lastLabel.set_label ("That's " + this.perKitten + " can(s) of tuna per kitten.");
    
        }
    
    });
cs: 
        _newValue: function () {
    
            // Aktualizuje popisek, který zobrazuje, kolik konzerv připadá na jednu kočku
            this.perKitten = Math.floor((this._tuna.get_value() / this._kittens.get_value()))
            this._lastLabel.set_label ("That's " + this.perKitten + " can(s) of tuna per kitten.");
    
        }
    
    });

note: (itstool) path: section/p
en: Here we update the perKitten variable based on the SpinButtons' new values, and use the set_label property to refresh what _lastLabel shows. Since both SpinButtons have their value-changed signal connected to this function, every time either of the numbers changes this function will update the Label.
cs: Zde aktualizujeme proměnnou <var>perKitten</var> vycházející z nových hodnot v číselnících a použijeme vlastnost <code>set_label</code> k občerstvení údaje, který zobrazuje <code>_lastLabel</code>. Protože mají oba číselníky své signály <code>"value-changed"</code> napojené na tuto funkci, aktualizuje tato funkce popisek pokaždé, když se změní některá z hodnot.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new SpinButtonExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new SpinButtonExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished SpinButtonExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci konečné třídy SpinButtonExample a aplikaci spustíme.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class SpinButtonExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsspinbutton'
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Kitten Feeder"});
    
            // Create the first spinbutton using a function
            this._kittens = Gtk.SpinButton.new_with_range (1, 9001, 1);
            this._kittens.connect ("value-changed", this._newValue.bind(this));
    
            // Create an adjustment to use for the second spinbutton
            this._adjustment = new Gtk.Adjustment ({
                value: 1,
                lower: 0,
                upper: 9001,
                step_increment: 1,
                page_increment: 10 });
    
            // Create the second spinbutton
            this._tuna = new Gtk.SpinButton ({ adjustment: this._adjustment });
            this._tuna.connect ("value-changed", this._newValue.bind(this));
    
            // this._tuna.set_digits (1);
            // this._tuna.set_wrap (true);
    
            // Create the text labels to go with the spinbuttons
            this._startLabel = new Gtk.Label ({ label: "There are " });
            this._kittenLabel = new Gtk.Label ({ label: " kitten(s), and "});
            this._tunaLabel = new Gtk.Label ({ label: " can(s) of tuna."});
            this.perKitten = Math.floor((this._tuna.get_value() / this._kittens.get_value()));
            this._lastLabel = new Gtk.Label ({
                label: "That's " + this.perKitten + " can(s) of tuna per kitten." });
    
            // Create a grid to put the spinbuttons and their labels in
            this._spinGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_bottom: 20 });
    
            // Attach everything to the grid
            this._spinGrid.attach (this._startLabel, 0, 0, 1, 1);
            this._spinGrid.attach (this._kittens, 1, 0, 1, 1);
            this._spinGrid.attach (this._kittenLabel, 2, 0, 1, 1);
            this._spinGrid.attach (this._tuna, 3, 0, 1, 1);
            this._spinGrid.attach (this._tunaLabel, 4, 0, 1, 1);
    
            // Create a main grid to hold it and the last label
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Attach the smaller grid and the last label to the main grid
            this._mainGrid.attach (this._spinGrid, 0, 0, 1, 1);
            this._mainGrid.attach (this._lastLabel, 0, 1, 1, 1);
    
            // Add the main grid to the window
            this._window.add (this._mainGrid);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _newValue() {
            // Update the label which shows how many cans there are per kitten
            this.perKitten = Math.floor((this._tuna.get_value() / this._kittens.get_value()))
            this._lastLabel.set_label ("That's " + this.perKitten + " can(s) of tuna per kitten.");
        }
    };
    
    // Run the application
    let app = new SpinButtonExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class SpinButtonExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsspinbutton'
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Kitten Feeder"});
    
            // Vytvoří pomocí funkce první číselník
            this._kittens = Gtk.SpinButton.new_with_range (1, 9001, 1);
            this._kittens.connect ("value-changed", this._newValue.bind(this));
    
            // Vytvoří přizpůsobení, které se použije pro druhý číselník
            this._adjustment = new Gtk.Adjustment ({
                value: 1,
                lower: 0,
                upper: 9001,
                step_increment: 1,
                page_increment: 10 });
    
            // Vytvoří druhý číselník
            this._tuna = new Gtk.SpinButton ({ adjustment: this._adjustment });
            this._tuna.connect ("value-changed", this._newValue.bind(this));
    
            // this._tuna.set_digits (1);
            // this._tuna.set_wrap (true);
    
            // Vytvoří textový popisek, který bude u číselníku
            this._startLabel = new Gtk.Label ({ label: "There are " });
            this._kittenLabel = new Gtk.Label ({ label: " kitten(s), and "});
            this._tunaLabel = new Gtk.Label ({ label: " can(s) of tuna."});
            this.perKitten = Math.floor((this._tuna.get_value() / this._kittens.get_value()));
            this._lastLabel = new Gtk.Label ({
                label: "That's " + this.perKitten + " can(s) of tuna per kitten." });
    
            // Vytvoří mřížku, do které se vloží číselníky a jejich popisky
            this._spinGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_bottom: 20 });
    
            // Připojí vše do mřížky
            this._spinGrid.attach (this._startLabel, 0, 0, 1, 1);
            this._spinGrid.attach (this._kittens, 1, 0, 1, 1);
            this._spinGrid.attach (this._kittenLabel, 2, 0, 1, 1);
            this._spinGrid.attach (this._tuna, 3, 0, 1, 1);
            this._spinGrid.attach (this._tunaLabel, 4, 0, 1, 1);
    
            // Vytvoří hlavní mřížku, která bude obsahovat poddružnou mřížku a poslední popisek
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Připojí poddružnou mříku a poslední popisek do hlavní mřížky
            this._mainGrid.attach (this._spinGrid, 0, 0, 1, 1);
            this._mainGrid.attach (this._lastLabel, 0, 1, 1, 1);
    
            // Přidá hlavní mřížku do okna
            this._window.add (this._mainGrid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _newValue() {
            // Aktualizuje popisek, který zobrazuje kolik konzerv připadá na jednu kočku
            this.perKitten = Math.floor((this._tuna.get_value() / this._kittens.get_value()))
            this._lastLabel.set_label ("That's " + this.perKitten + " can(s) of tuna per kitten.");
        }
    };
    
    // Spustí aplikaci
    let app = new SpinButtonExample ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: Retrieve an integer or floating-point number from the user.
cs: Získává celé nebo desetinné číslo od uživatele.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="SpinButton Example", application=app)
            self.set_default_size(210, 70)
            self.set_border_width(5)
    
            # an adjustment (initial value, min value, max value,
            # step increment - press cursor keys or +/- buttons to see!,
            # page increment - not used here,
            # page size - not used here)
            ad = Gtk.Adjustment(0, 0, 100, 1, 0, 0)
    
            # a spin button for integers (digits=0)
            self.spin = Gtk.SpinButton(adjustment=ad, climb_rate=1, digits=0)
            # as wide as possible
            self.spin.set_hexpand(True)
    
            # we connect the signal "value-changed" emitted by the spinbutton with the callback
            # function spin_selected
            self.spin.connect("value-changed", self.spin_selected)
    
            # a label
            self.label = Gtk.Label()
            self.label.set_text("Choose a number")
    
            # a grid to attach the widgets
            grid = Gtk.Grid()
            grid.attach(self.spin, 0, 0, 1, 1)
            grid.attach(self.label, 0, 1, 2, 1)
    
            self.add(grid)
    
        # callback function: the signal of the spinbutton is used to change the
        # text of the label
        def spin_selected(self, event):
            self.label.set_text(
                "The number you selected is " + str(self.spin.get_value_as_int()) + ".")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="SpinButton Example", application=app)
            self.set_default_size(210, 70)
            self.set_border_width(5)
    
            # Přizpůsobení (počáteční hodnota, min. hodnota, max. hodnota,
            # přírůstek kroku - viz zmáčknutí kurzorových kláves nebo +/-,
            # přírůstek stránky - zde nepoužito,
            # velikost stránky - zde nepoužito)
            ad = Gtk.Adjustment(0, 0, 100, 1, 0, 0)
    
            # Číselník pro celá čísla (digits=0)
            self.spin = Gtk.SpinButton(adjustment=ad, climb_rate=1, digits=0)
            # Tak široký, jak je možné
            self.spin.set_hexpand(True)
    
            # Napojí signál "value-changed" vyslaný číselníkem na funkci
            # zpětného volání spin_selected
            self.spin.connect("value-changed", self.spin_selected)
    
            # Popisek
            self.label = Gtk.Label()
            self.label.set_text("Choose a number")
    
            # Mřížka pro připojení widgetů
            grid = Gtk.Grid()
            grid.attach(self.spin, 0, 0, 1, 1)
            grid.attach(self.label, 0, 1, 2, 1)
    
            self.add(grid)
    
        # Funkce zpětného volání: signál widgetu SpinButton je použit ke změně
        # textu popisku
        def spin_selected(self, event):
            self.label.set_text(
                "The number you selected is " + str(self.spin.get_value_as_int()) + ".")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a SpinButton widget
cs: Užitečné metody pro widget SpinButton

note: (itstool) path: section/p
en: A Gtk.Adjustment is needed to construct the Gtk.SpinButton. This is the representation of a value with a lower and upper bound, together with step and page increments, and a page size, and it is constructed as <code>Gtk.Adjustment(value, lower, upper, step_increment, page_increment, page_size)</code> where the fields are of type <code>float</code>; <code>step_increment</code> is the increment/decrement that is obtained by using the cursor keys or the buttons of the spinbutton. Note that <code>page_increment</code> and <code>page_size</code> are not used in this case, and they should be set to <code>0</code>.
cs: <code>Gtk.Adjustment</code> je zapotřebí k vytvoření <code>Gtk.SpinButton</code>. Představuje hodnoty se spodní a horní hranicí, spolu s přírůstkem kroku a stránky a velikostí stránky, a vytváří se pomocí <code>Gtk.Adjustment(hodnota, spodní, horní, přírůstek_kroku, přírůstek_stránky, velikost_stránky)</code>, kde jednotlivé parametry jsou typu <code>float</code>. <code>přírůstek_kroku</code> určuje o kolik se má zvýšit/snížit hodnota při použití kurzorových kláves. Poznamenejme, že <code>přírůstek_stránky</code> a <code>velikost_stránky</code> zde nevyužíváme a měly by být nastaveny na <code>0</code>.

note: (itstool) path: section/p
en: In line 23 the signal <code>"value-changed"</code> is connected to the callback function <code>spin_selected()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 23 je signál <code>"value-changed"</code> napojen na funkci zpětného volání <code>spin_selected()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: If you want the value of the spinbutton to wrap around when they exceed the maximum or the minimum, set <code>set_wrap(True)</code>. The <code>"wrapped"</code> signal is emitted when this happens.
cs: Pokud chcete, aby hodnota v číselníku přecházela dokola přes meze, když dosáhne maxima nebo minima, nastavte <code>set_wrap(True)</code>. Když se tak stane, je vyslán signál <code>"wrapped"</code>.

note: (itstool) path: item/p
en: <code>set_digits(digits)</code> sets the precision to be displayed by the spinbutton, up to 20 digits.
cs: <code>set_digits(digits)</code> nastavuje přesnost zobrazení číselníkem, až na 20 číslic.

note: (itstool) path: item/p
en: To get the value of the spinbutton as an integer, use <code>get_value_as_int()</code>.
cs: Pro získání hodnoty z číselníku v podobě celého čísla použijte <code>get_value_as_int()</code>.

note: (itstool) path: info/desc
en: Retrieve an integer or floating point number.
cs: Získává celé nebo desetinné číslo.

note: (itstool) path: page/code
en: /* This is the application. */
    public class MyApplication : Gtk.Application {
    	Gtk.Label label;
    
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "SpinButton Example";
    		window.set_default_size (210, 70);
    		window.set_border_width (5);
    
    		var spinbutton = new Gtk.SpinButton.with_range (0, 100, 1);
    		spinbutton.set_hexpand (true);
    
    		label = new Gtk.Label ("Choose a number");
    
    		var grid = new Gtk.Grid ();
    		grid.attach (spinbutton, 0, 0, 1, 1);
    		grid.attach (label, 0, 1, 1, 1);
    
    		spinbutton.value_changed.connect (this.value_changed_cb);
    
    		window.add (grid);
    		window.show_all ();
    	}
    
    	void value_changed_cb (Gtk.SpinButton spin) {
    		label.set_text ("The number you selected is %.0f.".printf (spin.get_value()));
    	}
    }
    
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* This is the application. */
    public class MyApplication : Gtk.Application {
    	Gtk.Label label;
    
    	/* Přepíše signál "activate" z GLib.Application. */
    	protected override void activate () {
    		var window = new Gtk.ApplicationWindow (this);
    		window.title = "SpinButton Example";
    		window.set_default_size (210, 70);
    		window.set_border_width (5);
    
    		var spinbutton = new Gtk.SpinButton.with_range (0, 100, 1);
    		spinbutton.set_hexpand (true);
    
    		label = new Gtk.Label ("Choose a number");
    
    		var grid = new Gtk.Grid ();
    		grid.attach (spinbutton, 0, 0, 1, 1);
    		grid.attach (label, 0, 1, 1, 1);
    
    		spinbutton.value_changed.connect (this.value_changed_cb);
    
    		window.add (grid);
    		window.show_all ();
    	}
    
    	void value_changed_cb (Gtk.SpinButton spin) {
    		label.set_text ("The number you selected is %.0f.".printf (spin.get_value()));
    	}
    }
    
    /* main vytvoří a spustí aplikaci */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: A spinner animation
cs: Animovaná káča

note: (itstool) path: page/p
en: This Spinner is stopped and started by pressing the spacebar.
cs: Tento widget Spinner se zastavuje a spouští zmáčknutím mezerníku.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
     
    
    
     /*Global variable used to indicate active state of the
    spinner. TRUE = active, FALSE = not-active. This is because 
    there isn't a current function for C that does this for us*/
    gboolean active;  
     
    
    
    /*This is the callback function. It is a handler function 
    which reacts to the signal. In this case, it will cause the 
    spinner to start and stop according to how many times the user 
    presses the spacebar.*/ 
    static gboolean
    key_pressed_event (GtkWidget *widget,
                       GdkEvent  *event,
                       gpointer   user_data)
    {
      GtkWidget *spinner = user_data;
      guint keyval;
      
      /*Extracts the keyval from an event. And stores it in the  variable 
      "keyval" (we give the function the address). In this case, the 
      event is GdkEventKey, a key press event*/
      gdk_event_get_keyval (event, &amp;keyval);  
    
      /*Grabbing the boolean value from the spinner*/
      g_object_get (GTK_SPINNER (spinner), "active", &amp;active, NULL);
      
      if (keyval == GDK_KEY_space) {
         if (active) {
             gtk_spinner_stop (GTK_SPINNER (spinner));
         }
         else {
             gtk_spinner_start (GTK_SPINNER (spinner));
         } 
      }
      
    return TRUE;
    }
     
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *spinner;
     
      /*Create a window with a title, border width and a default size*/
      window = gtk_application_window_new (app);
     
      gtk_window_set_title (GTK_WINDOW (window), "Spinner Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
      gtk_container_set_border_width (GTK_CONTAINER(window), 30);
     
      /*Create a spinner, with extra horizontal and vertical space*/
      spinner = gtk_spinner_new ();
      gtk_spinner_start (GTK_SPINNER (spinner));
      
      gtk_container_add (GTK_CONTAINER (window), spinner);
     
      /*Connecting the key-press-event signal to the callback*/
      g_signal_connect (GTK_WINDOW (window), "key-press-event", 
                        G_CALLBACK (key_pressed_event), spinner);
     
      gtk_widget_show_all (window);
    }
     
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
     
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
     
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
     
    
    
     /* Globální proměnná použitá k indikaci stavu aktivity káči.
        TRUE = activní, FALSE = neaktivní. To je proto, že v současnosti 
        neexistuje žádná funkce v C, která by to pro nás dělala. */
    gboolean active;  
     
    
    
    /*Toto je funkce zpětného volání. Jedná se o zpracující funkci, 
      která reaguje na signál. V tomto případě způsobí, že káča 
      se začne otáčet a zastaví se, podle toho, kolikrát uživatel
      zmáčkl mezerník. */ 
    static gboolean
    key_pressed_event (GtkWidget *widget,
                       GdkEvent  *event,
                       gpointer   user_data)
    {
      GtkWidget *spinner = user_data;
      guint keyval;
      
      /* Vytáhne z události hodnodu klávesy. A uloží ji do proměnné
         „keyval“ (funkci předáme adresu). V tomto případě je událostí
         GdkEventKey a událost zmáčknutí klávesy */
      gdk_event_get_keyval (event, &amp;keyval);  
    
      /* Získání pravdivostní hodnoty od káči. */
      g_object_get (GTK_SPINNER (spinner), "active", &amp;active, NULL);
      
      if (keyval == GDK_KEY_space) {
         if (active) {
             gtk_spinner_stop (GTK_SPINNER (spinner));
         }
         else {
             gtk_spinner_start (GTK_SPINNER (spinner));
         } 
      }
      
    return TRUE;
    }
     
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *spinner;
     
      /* Vytvoří okno s názvem, šířkou okraje a výchozí velikostí */
      window = gtk_application_window_new (app);
     
      gtk_window_set_title (GTK_WINDOW (window), "Spinner Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
      gtk_container_set_border_width (GTK_CONTAINER(window), 30);
     
      /* Vytvoří Spinner s dodatečným místem vodorovně i svisle */
      spinner = gtk_spinner_new ();
      gtk_spinner_start (GTK_SPINNER (spinner));
      
      gtk_container_add (GTK_CONTAINER (window), spinner);
     
      /* Napojí signál "key-press-event" na zpětné volání */
      g_signal_connect (GTK_WINDOW (window), "key-press-event", 
                        G_CALLBACK (key_pressed_event), spinner);
     
      gtk_widget_show_all (window);
    }
     
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
     
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
     
      return status;
    }

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gdk = '3.0';
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    const Gdk = imports.gi.Gdk;
    
    class SpinnerExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsspinner',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Spinner Example",
                default_height: 200,
                default_width: 200,
                border_width: 30
            });
    
            // Create a spinner which starts spinning automatically
            this._spinner = new Gtk.Spinner ({active: true});
            this._window.add (this._spinner);
    
            // Connect a keypress event to the function that makes it start or stop spinning
            this._window.connect("key-press-event", this._onKeyPress.bind(this));
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _onKeyPress(widget, event) {
    
            // Get the value of the key that was pressed
            let [, keyval] = event.get_keyval();
    
            // If it was the spacebar, toggle the spinner to start or stop
            if (keyval == Gdk.KEY_space) {
                if (this._spinner.active == true)
                    this._spinner.stop();
                else
                    this._spinner.start();
            }
        }
    };
    
    // Run the application
    let app = new SpinnerExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gdk = '3.0';
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    const Gdk = imports.gi.Gdk;
    
    class SpinnerExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsspinner',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Spinner Example",
                default_height: 200,
                default_width: 200,
                border_width: 30
            });
    
            // Vytvoří káču která se začne automaticky točit
            this._spinner = new Gtk.Spinner ({active: true});
            this._window.add (this._spinner);
    
            // Napojít událost zmáčknutí klávesy na funkci, která spustí nebo zastaví otáčení
            this._window.connect("key-press-event", this._onKeyPress.bind(this));
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _onKeyPress(widget, event) {
    
            // Získá hodnotu klávesy, která byla zmáčknuta
            let [, keyval] = event.get_keyval();
    
            // Pokud se jedná o mezerník, přepne stav káči spuštěno/zastaveno
            if (keyval == Gdk.KEY_space) {
                if (this._spinner.active == true)
                    this._spinner.stop();
                else
                    this._spinner.start();
            }
        }
    };
    
    // Spustí aplikaci
    let app = new SpinnerExample ();
    app.application.run (ARGV);

note: (itstool) path: item/p
en: <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gdk.html">Gdk - Key Values</link>
cs: <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gdk.html">Gdk – Hodnoty kláves</link>

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Gdk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # a window
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Spinner Example", application=app)
            self.set_default_size(200, 200)
            self.set_border_width(30)
    
            # a spinner
            self.spinner = Gtk.Spinner()
            # that by default spins
            self.spinner.start()
            # add the spinner to the window
            self.add(self.spinner)
    
        # event handler
        # a signal from the keyboard (space) controls if the spinner stops/starts
        def do_key_press_event(self, event):
            # keyname is the symbolic name of the key value given by the event
            keyname = Gdk.keyval_name(event.keyval)
            # if it is "space"
            if keyname == "space":
                # and the spinner is active
                if self.spinner.get_property("active"):
                    # stop the spinner
                    self.spinner.stop()
                # if the spinner is not active
                else:
                    # start it again
                    self.spinner.start()
            # stop the signal emission
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Gdk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # Okno
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Spinner Example", application=app)
            self.set_default_size(200, 200)
            self.set_border_width(30)
    
            # Káča
            self.spinner = Gtk.Spinner()
            # Ve výchozím stavu se točí
            self.spinner.start()
            # Přidá káču do okna
            self.add(self.spinner)
    
        # Obsluha události
        # Signál od klávesnice (mezerník) ovládá spuštění/zastavení káči
        def do_key_press_event(self, event):
            # keyname je symbolický název k hodnotě klávesy poskytnuté událostí
            keyname = Gdk.keyval_name(event.keyval)
            # Jestliže je "space" (mezerník)
            if keyname == "space":
                # A káča je aktivní
                if self.spinner.get_property("active"):
                    # Zastaví káču
                    self.spinner.stop()
                # Jestliže káča není aktivní
                else:
                    # Znovu spustí káču
                    self.spinner.start()
            # Zastaví vysílání signálu
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: note/p
en: <code>Gdk.keyval_name(event.keyval)</code> converts the key value <code>event.keyval</code> into a symbolic name. The names and corresponding key values can be found <link href="https://gitlab.gnome.org/GNOME/gtk/blob/master/gdk/gdkkeysyms.h">here</link>, but for instance <code>GDK_KEY_BackSpace</code> becomes the string <code>"BackSpace"</code>.
cs: <code>Gdk.keyval_name(event.keyval)</code> převádí hodnotu klávesy <code>event.keyval</code> na symbolický název. Názvy a odpovídající hodnoty kláves můžete najít <link href="https://gitlab.gnome.org/GNOME/gtk/blob/master/gdk/gdkkeysyms.h">zde</link>, ale například <code>GDK_KEY_BackSpace</code> se změní na řetězec <code>"BackSpace"</code>.

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/gdk/stable/gdk-Keyboard-Handling.html">Key Values</link>
cs: <link href="http://developer.gnome.org/gdk/stable/gdk-Keyboard-Handling.html">Hodnoty klíčů</link>

note: (itstool) path: info/desc
en: Report messages of minor importance to the user
cs: Oznamuje uživateli zprávy s nižší důležitostí

note: (itstool) path: page/p
en: This statusbar is used to demonstrate how messages are stacked in a last-in-first-out order. The message at the top of the stack is always the one displayed.
cs: Tato stavová lišta je použita jako názorný příklad, jak jsou zprávy ukládány do zásobníku v pořadí poslední-dovnitř-první-ven (LIFO). Zpráva na vrcholu zásobníku je vždy ta, která je zobrazená.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /*Callback function in which pushes an item onto the statusbar*/
    static void 
    push_item (GtkWidget *widget,
               gpointer   data)
    {
      GtkWidget *status_bar = data;
    
      /*Create a context id, which is used to uniquely identify 
       *the source of a message*/
      guint context_id = gtk_statusbar_get_context_id (GTK_STATUSBAR (status_bar), 
                                                       "Statusbar example");
    
      /*Count is used to keep track of the amount of items 
      the user is pushing/popping*/
      static int count = 1;
      char hold_output[20];
      
      /*This is a safer form of the standard sprintf () function. The output is 
      guaranteed in this case to not exceed 20 characters, and the result is stored
      into the 'hold_output' variable*/
      g_snprintf (hold_output, 20, "Item %d", count++);
      gtk_statusbar_push (GTK_STATUSBAR (status_bar), 
                         context_id, 
                         hold_output);
    }
    
    
    
    /*Callback function that is used to pop an item off the statusbar*/
    static void 
    pop_item (GtkWidget *widget,
              gpointer   data )
    {
      GtkWidget *status_bar = data;
      guint context_id = gtk_statusbar_get_context_id (GTK_STATUSBAR (status_bar), 
                                                       "Statusbar example");
    
      gtk_statusbar_pop (GTK_STATUSBAR (status_bar), context_id);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
        GtkWidget *grid;
        GtkWidget *window;
        GtkWidget *status_bar;
        GtkWidget *pop_button;
        GtkWidget *push_button;
    
        /*Create a window with a title, border width, and a default size**/
        window = gtk_application_window_new (app);
        gtk_window_set_default_size (GTK_WINDOW (window), 220, 100);
        gtk_window_set_title (GTK_WINDOW (window), "Statusbar Example");
        gtk_container_set_border_width (GTK_CONTAINER(window), 10);
        
        /*Create the status bar, which is held in the global variable*/
        status_bar = gtk_statusbar_new ();      
        
        /*Create the buttons with labels*/
        push_button = gtk_button_new_with_label ("push item");
        pop_button = gtk_button_new_with_label ("pop last item");
        
        /*Create the grid, and attach the buttons/statusbar accordingly*/
        grid = gtk_grid_new ();
        gtk_grid_attach (GTK_GRID (grid), push_button, 0,1,1,1);
        gtk_grid_attach (GTK_GRID (grid), pop_button, 0,2,1,1);
        gtk_grid_attach (GTK_GRID (grid), status_bar, 0,3,1,1);
        
        /*Connecting the clicked signals to the corresponding callback functions*/
        g_signal_connect (GTK_BUTTON (push_button), "clicked", 
                          G_CALLBACK (push_item), status_bar);
        g_signal_connect (GTK_BUTTON (pop_button), "clicked", 
                          G_CALLBACK (pop_item), status_bar);
        
        /*Attach the grid holding the child widgets onto the window, and show all*/
        gtk_container_add (GTK_CONTAINER (window), grid);
        gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Funkce zpětného volání, ve které vložíme položku do stavové lišty */
    static void 
    push_item (GtkWidget *widget,
               gpointer   data)
    {
      GtkWidget *status_bar = data;
    
      /* Vytvoří ID kontextu, které slouží k jedinečné identifikaci 
       * zdroje zprávy */
      guint context_id = gtk_statusbar_get_context_id (GTK_STATUSBAR (status_bar), 
                                                       "Statusbar example");
    
      /* Počitadlo je použito k udržování přehledu o množství položek, 
       * které uživatel vložil/vytáhl */
      static int count = 1;
      char hold_output[20];
      
      /* Toto je bezpečnější, než standardní funkce sprintf(). Je zaručno, že výstup
       * v tomto případě nepřesáhne 20 znaků a výsledek je uchován v proměnné 
       * 'hold_output' */
      g_snprintf (hold_output, 20, "Item %d", count++);
      gtk_statusbar_push (GTK_STATUSBAR (status_bar), 
                         context_id, 
                         hold_output);
    }
    
    
    
    /* Funkce zpětného volání, která je použita k vytažení položky ze stavové lišty */
    static void 
    pop_item (GtkWidget *widget,
              gpointer   data )
    {
      GtkWidget *status_bar = data;
      guint context_id = gtk_statusbar_get_context_id (GTK_STATUSBAR (status_bar), 
                                                       "Statusbar example");
    
      gtk_statusbar_pop (GTK_STATUSBAR (status_bar), context_id);
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
        GtkWidget *grid;
        GtkWidget *window;
        GtkWidget *status_bar;
        GtkWidget *pop_button;
        GtkWidget *push_button;
    
        /* Vytvoří okno s názvem, šířkou okraje a výchozí velikostí */
        window = gtk_application_window_new (app);
        gtk_window_set_default_size (GTK_WINDOW (window), 220, 100);
        gtk_window_set_title (GTK_WINDOW (window), "Statusbar Example");
        gtk_container_set_border_width (GTK_CONTAINER(window), 10);
        
        /* Vytvoří stavovou lištu, která udržuje globální proměnnou */
        status_bar = gtk_statusbar_new ();      
        
        /* Vytvoří tlačítka s popisky */
        push_button = gtk_button_new_with_label ("push item");
        pop_button = gtk_button_new_with_label ("pop last item");
        
        /* Vytvoří mřížku a správně do ní připojí tlačítka/stavovou lištu */
        grid = gtk_grid_new ();
        gtk_grid_attach (GTK_GRID (grid), push_button, 0,1,1,1);
        gtk_grid_attach (GTK_GRID (grid), pop_button, 0,2,1,1);
        gtk_grid_attach (GTK_GRID (grid), status_bar, 0,3,1,1);
        
        /* Napojí signály kliknutí k odpovídajícím funkcím zpětného volání */
        g_signal_connect (GTK_BUTTON (push_button), "clicked", 
                          G_CALLBACK (push_item), status_bar);
        g_signal_connect (GTK_BUTTON (pop_button), "clicked", 
                          G_CALLBACK (pop_item), status_bar);
        
        /* Připojí mřížku uchovávající synovské widgety do okna a zobrazí jej */
        gtk_container_add (GTK_CONTAINER (window), grid);
        gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/glib/stable/glib-String-Utility-Functions.html#g-snprintf">String Utility Functions</link>
cs: <link href="http://developer.gnome.org/glib/stable/glib-String-Utility-Functions.html#g-snprintf">Funkce pro práci s řetězci</link>

note: (itstool) path: info/desc
en: Show notifications in a dedicated statusbar
cs: Zobrazuje upozornění ve vyhrazené stavové liště

note: (itstool) path: page/p
en: This statusbar keeps track of how many times you've clicked a button. Applications like <link href="https://wiki.gnome.org/Apps/Gedit">gedit</link> use statusbars to display information at a glance, and show notifications without interrupting the user.
cs: Tato stavová lišta sleduje, kolikrát jste klikli na tlačítko. Aplikace, jako je <link href="https://wiki.gnome.org/Apps/Gedit">gedit</link>, používají stavovou lištu k přehlednému zobrazení informací a k upozorněním, která uživatele nepřeruší v práci.

note: (itstool) path: page/p
en: Messages pushed to a statusbar go on top of its stack, and can be popped off to show the next-most recent one. You can also clear away every message of a specific type all at once. This sample application demonstrates these functions.
cs: Zprávy vložené do stavové lišty se umístí na vrchol zásobníku a od tam mohou být vybrány k zobrazení nejnovější zprávy. Můžete také naráz vymazat všechny zprávy určitého typu. Tato ukázková aplikace předvádí právě tyto funkce.

note: (itstool) path: section/code
en: 
    const StatusbarExample = new Lang.Class({
        Name: 'Statusbar Example',
    
        // Create the application itself
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsstatusbar',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Connect 'activate' and 'startup' signals to the callback functions
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Callback function for 'activate' signal presents window when active
        _onActivate: function() {
            this._window.present();
        },
    
        // Callback function for 'startup' signal builds the UI
        _onStartup: function() {
            this._buildUI ();
        },
cs: 
    const StatusbarExample = new Lang.Class({
        Name: 'Statusbar Example',
    
        // Vytvoří vlastní aplikaci
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsstatusbar',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate: function() {
            this._window.present();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function() {
            this._buildUI ();
        },

note: (itstool) path: section/p
en: All the code for this sample goes in the StatusbarExample class. The above code creates a <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> for our widgets and window to go in.
cs: Všechen kód této ukázky je ve třídě <code>StatusbarExample</code>. Výše uvedený kód vytvoří <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> pro naše widgety a okno, ve kterém budou.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI: function() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 120,
                default_width: 300,
                title: "Button Clicker"});
    
            // Create a paned interface
            this._panes = new Gtk.Paned ({
                orientation: Gtk.Orientation.VERTICAL });
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 120,
                default_width: 300,
                title: "Button Clicker"});
    
            // Vytvoří dvoupanelového rozhraní
            this._panes = new Gtk.Paned ({
                orientation: Gtk.Orientation.VERTICAL });

note: (itstool) path: section/p
en: The _buildUI function is where we put all the code to create the application's user interface. The first step is creating a new <link href="GtkApplicationWindow.js.page">Gtk.ApplicationWindow</link> to put all our widgets into. The next step is to create a vertically-oriented Gtk.Paned interface, to divide the window up into two sections. This way the statusbar looks like those used in other applications, and it stays at the bottom of the window, even if the user resizes it.
cs: Funkce <code>_buildUI</code> je místo, ze kterého voláme všechen kód, který vytváří uživatelské rozhraní aplikace. Prvním krokem je vytvoření nového <link href="GtkApplicationWindow.js.page">Gtk.ApplicationWindow</link>, do kterého vložíme všechny naše widgety. Následujícím krokem je vytvoření svisle orientovaného rozhraní Gtk.Paned, které rozdělí okno na dvě části. Díky tomu stavová lišta vypadá stejně, jako jste zvyklí z jiných aplikací, a zůstává v dolní části okna, i když uživatel mění jeho velikost.

note: (itstool) path: section/title
en: Creating the buttons
cs: Vytvoření tlačítek

note: (itstool) path: section/code
en: 
            // Create the main button
            this._clickMe = new Gtk.Button ({
                label: "Click Me!" });
            this._clickMe.connect ("clicked", Lang.bind (this, this._clicked));
    
            // Create the back button
            this._backButton = new Gtk.Button ({
                label: "gtk-go-back",
                use_stock: true });
            this._backButton.connect ("clicked", Lang.bind (this, this._back));
    
            // Create the clear button
            this._clearButton = new Gtk.Button ({
                label: "gtk-clear",
                use_stock: true });
            this._clearButton.connect ("clicked", Lang.bind (this, this._clear));
cs: 
            // Vytvoří hlavní tlačítko
            this._clickMe = new Gtk.Button ({
                label: "Click Me!" });
            this._clickMe.connect ("clicked", Lang.bind (this, this._clicked));
    
            // Vytvoří tlačítko Undo
            this._backButton = new Gtk.Button ({
                label: "gtk-go-back",
                use_stock: true });
            this._backButton.connect ("clicked", Lang.bind (this, this._back));
    
            // Vytvoří tlačítko Clear
            this._clearButton = new Gtk.Button ({
                label: "gtk-clear",
                use_stock: true });
            this._clearButton.connect ("clicked", Lang.bind (this, this._clear));

note: (itstool) path: section/p
en: This code creates the three <link href="button.js.page">Gtk.Buttons</link> we'll use to push a new message to the statusbar, pop the last one off, and clear all existing messages. The "back" and "clear" buttons are <link href="https://developer.gnome.org/gtk3/3.4/gtk3-Stock-Items.html">stock buttons</link>, which are automatically translated into any language GNOME supports.
cs: Tento kód vytvoří tři <link href="button.js.page">Gtk.Button</link>, která použijeme ke vkládání zprávy do stavové lišty, k odebírání poslední zprávy a k mazání všech existujících zpráv. Tlačítka <gui>Back</gui> a <gui>Clear</gui> jsou <link href="https://developer.gnome.org/gtk3/3.4/gtk3-Stock-Items.html">standardní tlačítka</link>, která jsou automaticky přeložena do kteréhokoliv národního jazyka, který GNOME podporuje.

note: (itstool) path: section/code
en: 
            // Put the buttons in a grid
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
            this._grid.attach (this._backButton, 0, 0, 1, 1);
            this._grid.attach_next_to (this._clickMe, this._backButton, Gtk.PositionType.RIGHT, 1, 1);
            this._grid.attach_next_to (this._clearButton, this._clickMe, Gtk.PositionType.RIGHT, 1, 1);
    
            // Put the grid in a large frame that fills most of the window
            this._topFrame = new Gtk.Frame ({
                border_width: 20,
                height_request: 90,
                width_request: 300});
            this._topFrame.add (this._grid);
cs: 
            // Vloží tlačítka do mřížky
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
            this._grid.attach (this._backButton, 0, 0, 1, 1);
            this._grid.attach_next_to (this._clickMe, this._backButton, Gtk.PositionType.RIGHT, 1, 1);
            this._grid.attach_next_to (this._clearButton, this._clickMe, Gtk.PositionType.RIGHT, 1, 1);
    
            // Vloží mřížku do většího rámu, který vyplní většinu okna
            this._topFrame = new Gtk.Frame ({
                border_width: 20,
                height_request: 90,
                width_request: 300});
            this._topFrame.add (this._grid);

note: (itstool) path: section/p
en: This code creates the <link href="grid.js.page">Gtk.Grid</link> that we'll use to organize the buttons, and attaches the buttons to it in order. It then creates a <link href="paned.js.page">Gtk.Frame</link> which will take up most of the window and has a large amount of padding around the buttons, and adds the Grid to the Frame. Note that we still need to put the Frame into the Paned interface, and then add it to the ApplicationWindow.
cs: Tento kód vytvoří <link href="grid.js.page">Gtk.Grid</link>, kterou použijeme k uspořádání tlačítek, a tlačítka do mřížky ve správném pořadí připojí. Pak vytvoří <link href="paned.js.page">Gtk.Frame</link>, který zabere většinu okna a má velké odsazení okolo tlačítek, a přidá mřížku do tohoto rámu. Upozorňujeme, že stále potřebujeme vložit rám do dvoupanelového rozhraní a to zase přidat do okna aplikace.

note: (itstool) path: section/title
en: Creating the statusbar
cs: Vytvoření stavové lišty

note: (itstool) path: section/code
en: 
            // Create the statusbar
            this._statusbar = new Gtk.Statusbar();
    
            // Keep track of the number of times the button has been clicked
            this.Clicks = 0;
            this.ContextID = this._statusbar.get_context_id ("Number of Clicks");
    
            // Give the statusbar an initial message
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
    
            // Put the statusbar in its own frame at the bottom
            this._barFrame = new Gtk.Frame ({
                height_request: 30 });
            this._barFrame.add (this._statusbar);
cs: 
            // Vytvoří stavovou lištu
            this._statusbar = new Gtk.Statusbar();
    
            // Uchovává počet, kolikrát bylo na kliknuto na tlačítko
            this.Clicks = 0;
            this.ContextID = this._statusbar.get_context_id ("Number of Clicks");
    
            // Předá stavové liště počáteční zprávu
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
    
            // Vloží stavovou lištu do jím vlastněného rámu dole
            this._barFrame = new Gtk.Frame ({
                height_request: 30 });
            this._barFrame.add (this._statusbar);

note: (itstool) path: section/p
en: Here we create the Gtk.Statusbar, and push a message to it to start off with. Then we give it its own narrow frame at the bottom of the window.
cs: Zde vytvoříme <code>Gtk.Statusbar</code> a vložíme do něj zprávu, se kterou začne. Pak mu přidělíme vlastní úzký rám v dolní části okna.

note: (itstool) path: section/p
en: Every message needs to have a context id, which is an integer value you can get from the statusbar with the get_context_id() function. Its only parameter is the string value you use to describe that particular context id. Normally, you'll get a new context id for different kinds of messages, so that you can use the remove() function to remove a specific message and not just the most recent one on the stack. This is a simple example with only one kind of message, though, so we're just using one for everything.
cs: Každá zpráva musí mít ID kontexu, což je celočíselná hodnota, kterou můžete získat od stavové lišty pomocí funkce <code>get_context_id()</code>. Její jediný parametr je řetězcová hodnota, která slouží k popisu tohoto konkrétního kontextu. Za normálních okolností dostanete nové ID kontextu pro různé druhy zpráv, takže můžete použít funkci <code>remove()</code> k odstranění zadané zprávy a ne nutně jen nejnovější zprávy v zásobníku. Toto je jednoduchý příklad jen s jedním druhem zpráv, takže používáme jen jedno ID pro všechno.

note: (itstool) path: section/p
en: We use the push() function to push a new message onto the stack. Its first parameter is the context id, and its second is the message.
cs: Používáme funkci <code>push()</code> k vložení nové zprávy do zásobníku. Prvním parametrem je ID kontextu a druhým zpráva.

note: (itstool) path: section/code
en: 
            // Assemble the frames into the paned interface
            this._panes.pack1 (this._topFrame, true, false);
            this._panes.pack2 (this._barFrame, false, false);
    
            // Put the panes into the window
            this._window.add (this._panes);
    
            // Show the window and all child widgets
            this._window.show_all();
        },
cs: 
            // Sestaví rámy do dvoupanelového rozhraní
            this._panes.pack1 (this._topFrame, true, false);
            this._panes.pack2 (this._barFrame, false, false);
    
            // Vloží panely do okna
            this._window.add (this._panes);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        },

note: (itstool) path: section/p
en: This code finishes up creating the window, by packing the frames into the pane, adding it to the window, and telling the window to show all child widgets.
cs: Tento kód dokončí vytváření okna tím, že zabalí rámy do panelu, přidá jej do okna a řekne oknu, aby zobrazilo všechny synovské widgety.

note: (itstool) path: section/title
en: Functions for interacting with the statusbar
cs: Funkce pro komunikaci se stavovou lištou

note: (itstool) path: section/code
en: 
        _clicked: function() {
    
            // Increment the number of clicks by 1
            this.Clicks++;
    
            // Update the statusbar with the new number of clicks
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
    
        },
    
    
    
        _back: function () {
    
            // If there have been any clicks, decrement by 1 and remove last statusbar update
            if (this.Clicks &gt; 0 ) {
                this.Clicks--;
                this._statusbar.pop (this.ContextID);
            };
    
        },
    
    
    
        _clear: function () {
    
            // Reset the number of clicks
            this.Clicks = 0;
    
            // Wipe out all the messages pushed to the statusbar
            this._statusbar.remove_all (this.ContextID);
    
            // Reset the statusbar's message
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
    
        }
    
    });
cs: 
        _clicked: function() {
    
            // Zvýší počet kliknutí o 1
            this.Clicks++;
    
            // Aktualizuje stavovou lištu na nový počet kliknutí
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
    
        },
    
    
    
        _back: function () {
    
            // Pokud bylo kliknuto, sníží o 1 a odstraní poslední aktualizaci stavové lišty
            if (this.Clicks &gt; 0 ) {
                this.Clicks--;
                this._statusbar.pop (this.ContextID);
            };
    
        },
    
    
    
        _clear: function () {
    
            // Vynuluje počet kliknutí
            this.Clicks = 0;
    
            // Vymaže všechny zprávy vložené do stavové lišty
            this._statusbar.remove_all (this.ContextID);
    
            // Nataví výchozí zprávu ve stavové liště
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
    
        }
    
    });

note: (itstool) path: section/p
en: Here we have functions which demonstrate pushing a message onto the stack, popping the top one off of it, and clearing all messages of a particular context id. The pop() function just takes one parameter, which is the context id for the type of message you want to pop off the most recent one of. The remove_all() function works the same way, except it removes all messages of that type from the stack.
cs: Zde máme funkci, která předvádí vložení zprávy na zásobník, odebrání zprávy úplně na vrcholu zásobníku a smazání všech zpráv s konkrétním ID kontextu. Funkce <code>pop()</code> přebírá jen jeden parametr, což je ID kontextu pro typ zpráv, z nichž nejnovější chcete odebrat ze zásobníku. Funkce <code>remove_all()</code> pracuje stejným způsobem, akorát že odstraní ze zásobníku všechny zprávy zadaného typu.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new StatusbarExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new StatusbarExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished StatusbarExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci konečné třídy <code>StatusbarExample</code> a aplikaci spustíme.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class StatusbarExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsstatusbar',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 120,
                default_width: 300,
                title: "Button Clicker"});
    
            // Create a paned interface
            this._panes = new Gtk.Paned ({
                orientation: Gtk.Orientation.VERTICAL });
    
            // Create the main button
            this._clickMe = new Gtk.Button ({
                label: "Click Me!" });
            this._clickMe.connect ("clicked", this._clicked.bind(this));
    
            // Create the back button
            this._backButton = new Gtk.Button ({
                label: "gtk-go-back",
                use_stock: true });
            this._backButton.connect ("clicked", this._back.bind(this));
    
            // Create the clear button
            this._clearButton = new Gtk.Button ({
                label: "gtk-clear",
                use_stock: true });
            this._clearButton.connect ("clicked", this._clear.bind(this));
    
            // Put the buttons in a grid
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
            this._grid.attach (this._backButton, 0, 0, 1, 1);
            this._grid.attach_next_to (this._clickMe, this._backButton, Gtk.PositionType.RIGHT, 1, 1);
            this._grid.attach_next_to (this._clearButton, this._clickMe, Gtk.PositionType.RIGHT, 1, 1);
    
            // Put the grid in a large frame that fills most of the window
            this._topFrame = new Gtk.Frame ({
                border_width: 20,
                height_request: 90,
                width_request: 300});
            this._topFrame.add (this._grid);
    
            // Create the statusbar
            this._statusbar = new Gtk.Statusbar();
    
            // Keep track of the number of times the button has been clicked
            this.Clicks = 0;
            this.ContextID = this._statusbar.get_context_id ("Number of Clicks");
    
            // Give the statusbar an initial message
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
    
            // Put the statusbar in its own frame at the bottom
            this._barFrame = new Gtk.Frame ({
                height_request: 30 });
            this._barFrame.add (this._statusbar);
    
            // Assemble the frames into the paned interface
            this._panes.pack1 (this._topFrame, true, false);
            this._panes.pack2 (this._barFrame, false, false);
    
            // Put the panes into the window
            this._window.add (this._panes);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _clicked() {
    
            // Increment the number of clicks by 1
            this.Clicks++;
    
            // Update the statusbar with the new number of clicks
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
        }
    
        _back() {
    
            // If there have been any clicks, decrement by 1 and remove last statusbar update
            if (this.Clicks &gt; 0 ) {
                this.Clicks--;
                this._statusbar.pop (this.ContextID);
            };
        }
    
        _clear() {
    
            // Reset the number of clicks
            this.Clicks = 0;
    
            // Wipe out all the messages pushed to the statusbar
            this._statusbar.remove_all (this.ContextID);
    
            // Reset the statusbar's message
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
        }
    };
    
    // Run the application
    let app = new StatusbarExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class StatusbarExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsstatusbar',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 120,
                default_width: 300,
                title: "Button Clicker"});
    
            // Vytvoří dvoupanelového rozhraní
            this._panes = new Gtk.Paned ({
                orientation: Gtk.Orientation.VERTICAL });
    
            // Vytvoří hlavní tlačítko
            this._clickMe = new Gtk.Button ({
                label: "Click Me!" });
            this._clickMe.connect ("clicked", this._clicked.bind(this));
    
            // Vytvoří tlačítko Back
            this._backButton = new Gtk.Button ({
                label: "gtk-go-back",
                use_stock: true });
            this._backButton.connect ("clicked", this._back.bind(this));
    
            // Vytvoří tlačítko Clear
            this._clearButton = new Gtk.Button ({
                label: "gtk-clear",
                use_stock: true });
            this._clearButton.connect ("clicked", this._clear.bind(this));
    
            // Vloží tlačítka do mřížky
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
            this._grid.attach (this._backButton, 0, 0, 1, 1);
            this._grid.attach_next_to (this._clickMe, this._backButton, Gtk.PositionType.RIGHT, 1, 1);
            this._grid.attach_next_to (this._clearButton, this._clickMe, Gtk.PositionType.RIGHT, 1, 1);
    
            // Vloží mřížku do většího rámu, který vyplní většinu okna
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
            this._grid.attach (this._backButton, 0, 0, 1, 1);
            this._grid.attach_next_to (this._clickMe, this._backButton, Gtk.PositionType.RIGHT, 1, 1);
            this._grid.attach_next_to (this._clearButton, this._clickMe, Gtk.PositionType.RIGHT, 1, 1);
    
            // Vytvoří stavovou lištu
            this._statusbar = new Gtk.Statusbar();
    
            // Uchovává počet, kolikrát bylo na kliknuto na tlačítko
            this.Clicks = 0;
            this.ContextID = this._statusbar.get_context_id ("Number of Clicks");
    
            // Předá stavové liště počáteční zprávu
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
    
            // Vloží stavovou lištu do jím vlastněného rámu dole
            this._barFrame = new Gtk.Frame ({
                height_request: 30 });
            this._barFrame.add (this._statusbar);
    
            // Sestaví rámy do dvoupanelového rozhraní
            this._panes.pack1 (this._topFrame, true, false);
            this._panes.pack2 (this._barFrame, false, false);
    
            // Vloží panely do okna
            this._window.add (this._panes);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _clicked() {
    
            // Zvýší počet kliknutí o 1
            this.Clicks++;
    
            // Aktualizuje stavovou lištu na nový počet kliknutí
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
        }
    
        _back() {
    
            // Pokud bylo kliknuto, sníží o 1 a odstraní poslední aktualizaci stavové lišty
            if (this.Clicks &gt; 0 ) {
                this.Clicks--;
                this._statusbar.pop (this.ContextID);
            };
        }
    
        _clear() {
    
            // Vynuluje počet kliknutí
            this.Clicks = 0;
    
            // Vymaže všechny zprávy vložené do stavové lišty
            this._statusbar.remove_all (this.ContextID);
    
            // Nataví výchozí zprávu ve stavové liště
            this._statusbar.push (this.ContextID, "Number of clicks: " + this.Clicks);
        }
    };
    
    // Spustí aplikaci
    let app = new StatusbarExample ();
    app.application.run (ARGV);

note: (itstool) path: page/p
en: This statusbar tells you if you click the button or if you press any key (and which key).
cs: Tato stavová lišta vám sděluje, jestli jste klikli na tlačítko nebo jestli jste zmáčkli klávesu (a kterou).

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Gdk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # a window
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="StatusBar Example", application=app)
            self.set_default_size(200, 100)
    
            # a label
            label = Gtk.Label(label="Press any key or ")
    
            # a button
            button = Gtk.Button(label="click me.")
            # connected to a callback
            button.connect("clicked", self.button_clicked_cb)
    
            # the statusbar
            self.statusbar = Gtk.Statusbar()
            # its context_id - not shown in the UI but needed to uniquely identify
            # the source of a message
            self.context_id = self.statusbar.get_context_id("example")
            # we push a message onto the statusbar's stack
            self.statusbar.push(
                self.context_id, "Waiting for you to do something...")
    
            # a grid to attach the widgets
            grid = Gtk.Grid()
            grid.set_column_spacing(5)
            grid.set_column_homogeneous(True)
            grid.set_row_homogeneous(True)
            grid.attach(label, 0, 0, 1, 1)
            grid.attach_next_to(button, label, Gtk.PositionType.RIGHT, 1, 1)
            grid.attach(self.statusbar, 0, 1, 2, 1)
    
            # add the grid to the window
            self.add(grid)
    
        # callback function for the button clicked
        # if the button is clicked the event is signaled to the statusbar
        # onto which we push a new status
        def button_clicked_cb(self, button):
            self.statusbar.push(self.context_id, "You clicked the button.")
    
        # event handler
        def do_key_press_event(self, event):
        # any signal from the keyboard is signaled to the statusbar
        # onto which we push a new status with the symbolic name
        # of the key pressed
            self.statusbar.push(self.context_id, Gdk.keyval_name(event.keyval) +
                                " key was pressed.")
            # stop the signal emission
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Gdk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # Okno
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="StatusBar Example", application=app)
            self.set_default_size(200, 100)
    
            # Popisek
            label = Gtk.Label(label="Press any key or ")
    
            # Tlačítko
            button = Gtk.Button(label="click me.")
            # Napojí signál na zpětné volání
            button.connect("clicked", self.button_clicked_cb)
    
            # Stavová lišta
            self.statusbar = Gtk.Statusbar()
            # Její id_kontextu - nezobrazuje se v uživatelském rozhraní, ale je
            # potřeba k jednoznačné identifikaci zdroje zprávy
            self.context_id = self.statusbar.get_context_id("example")
            # Vloží zprávu do zásobníku stavové lišty
            self.statusbar.push(
                self.context_id, "Waiting for you to do something...")
    
            # Mřížka pro připojení widgetů
            grid = Gtk.Grid()
            grid.set_column_spacing(5)
            grid.set_column_homogeneous(True)
            grid.set_row_homogeneous(True)
            grid.attach(label, 0, 0, 1, 1)
            grid.attach_next_to(button, label, Gtk.PositionType.RIGHT, 1, 1)
            grid.attach(self.statusbar, 0, 1, 2, 1)
    
            # Přidá mřížku do okna
            self.add(grid)
    
        # Funkce zpětného volání pro kliknutí na tlačítko
        # Když je na tlačítko kliknuto, je událost signalizována stavové liště,
        # do které se vloží nový stav
        def button_clicked_cb(self, button):
            self.statusbar.push(self.context_id, "You clicked the button.")
    
        # Obsluha události
        def do_key_press_event(self, event):
        # Kterýkoliv signál od klávesnice je předán stavové liště, do
        # které je vložen nový stav se symbolickým názvem zmáčknuté klávesy
            self.statusbar.push(self.context_id, Gdk.keyval_name(event.keyval) +
                                " key was pressed.")
            # Zastaví vysílání signálu
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Statusbar widget
cs: Užitečné metody pro widget Statusbar

note: (itstool) path: section/p
en: In line 17 the signal <code>"clicked"</code> is connected to the callback function <code>button_clicked_cb()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 17 je signál <code>"clicked"</code> napojen na funkci zpětného volání <code>button_clicked_cb()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: <code>pop(context_id)</code> removes the first message in the statusbar stack with the given <code>context_id</code>.
cs: <code>pop(id_kontextu)</code> odstraní první zprávu ze zásobníku stavové lišty se zadaným <code>id_kontextu</code>.

note: (itstool) path: item/p
en: <code>remove_all(context_id)</code> removes all the messages in the statusbar stack with the given <code>context_id</code>.
cs: <code>remove_all(id_kontextu)</code> odstraní všechny zprávy ze zásobníku stavové lišty se zadaným <code>id_kontextu</code>.

note: (itstool) path: item/p
en: <code>remove(context_id, message_id)</code> removes the message with the given <code>message_id</code> in the statusbar stack with the given <code>context_id</code>. The <code>message_id</code> is returned by <code>push(context_id, "the message")</code> when pushing the message on the statusbar.
cs: <code>remove(id_kontextu, id_zprávy)</code> odstraní zprávu se zadaným <code>id_zprávy</code> ze zásobníku stavové lišty se zadaným <code>id_kontextu</code>. Hodnotu <code>id_zprávy</code> vrací funkce <code>push(id_kontextu, "zpráva")</code> při vkládání zprávy do stavové lišty.

note: (itstool) path: page/p
en: This statusbar tells you what's going on.
cs: Tato stavová lišta sděluje, co se děje.

note: (itstool) path: page/code
en: public class MyWindow : Gtk.ApplicationWindow {
    
    	Gtk.Statusbar statusbar;
    	uint context_id;
    
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Statusbar Example");
    
    		statusbar = new Gtk.Statusbar ();
    		context_id = statusbar.get_context_id ("example");
    		statusbar.push (context_id, "Waiting for you to do something...");
    
    		//set the default size of the window
    		this.set_default_size (200, 100);
    		var grid = new Gtk.Grid ();
    		var label = new Gtk.Label ("Press any key or ");
    
    		grid.attach (label, 0, 0, 1, 1);
    		label.show ();
    
    		var button = new Gtk.Button.with_label ("click me.");
    		grid.attach_next_to (button, label, Gtk.PositionType.RIGHT, 1, 1);
    		button.show ();
    
    		grid.attach (statusbar, 0, 1, 2, 1);
    		statusbar.show ();
    
    		grid.set_column_spacing (5);
    		grid.set_column_homogeneous (true);
    		grid.set_row_homogeneous (true);
    
    		this.add (grid);
    		grid.show ();
    
    		button.clicked.connect(button_clicked_cb);
    	}
    
    	/* Since the key-press-event is a signal received by the window, we don't need to connect
    	the window to a callback function.  We can just override key_press_event. */
    	protected override bool key_press_event (Gdk.EventKey event) {
    		statusbar.push (context_id, Gdk.keyval_name(event.keyval) + " key was pressed.");
    		return true;
    	}
    
    	void button_clicked_cb (Gtk.Button button) {
    		statusbar.push (context_id, "You clicked the button.");
    	}
    }
    
    public class MyApplication : Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    	internal MyApplication () {
    		Object (application_id: "org.example.status");
    	}
    }
    
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: public class MyWindow : Gtk.ApplicationWindow {
    
    	Gtk.Statusbar statusbar;
    	uint context_id;
    
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Statusbar Example");
    
    		statusbar = new Gtk.Statusbar ();
    		context_id = statusbar.get_context_id ("example");
    		statusbar.push (context_id, "Waiting for you to do something...");
    
    		// Nastaví výchozí velikost okna
    		this.set_default_size (200, 100);
    		var grid = new Gtk.Grid ();
    		var label = new Gtk.Label ("Press any key or ");
    
    		grid.attach (label, 0, 0, 1, 1);
    		label.show ();
    
    		var button = new Gtk.Button.with_label ("click me.");
    		grid.attach_next_to (button, label, Gtk.PositionType.RIGHT, 1, 1);
    		button.show ();
    
    		grid.attach (statusbar, 0, 1, 2, 1);
    		statusbar.show ();
    
    		grid.set_column_spacing (5);
    		grid.set_column_homogeneous (true);
    		grid.set_row_homogeneous (true);
    
    		this.add (grid);
    		grid.show ();
    
    		button.clicked.connect(button_clicked_cb);
    	}
    
    	/* Protože "key-press-event" je signál přijímaný oknem, nepotřebujeme napojovat
    	 * okno na funkci zpětného volání. Stačí přepsat funkci key_press_event */
    	protected override bool key_press_event (Gdk.EventKey event) {
    		statusbar.push (context_id, Gdk.keyval_name(event.keyval) + " key was pressed.");
    		return true;
    	}
    
    	void button_clicked_cb (Gtk.Button button) {
    		statusbar.push (context_id, "You clicked the button.");
    	}
    }
    
    public class MyApplication : Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    	internal MyApplication () {
    		Object (application_id: "org.example.status");
    	}
    }
    
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: An explanation of how to deal with strings in Python and GTK+.
cs: Vysvětlení, jak zacházet s řetězci v jazyce Python a v GTK+.

note: (itstool) path: note/p
en: GNOME strongly encourages the use of Python 3 for writing applications!
cs: GNOME důrazně doporučuje používat pro psaní aplikací Python 3!

note: (itstool) path: section/title
en: Strings in Python 2
cs: Řetězce v jazyce Python 2

note: (itstool) path: section/p
en: Python 2 comes with two different kinds of objects that can be used to represent strings, <code>str</code> and <code>unicode</code>. Instances of <code>unicode</code> are used to express Unicode strings, whereas instances of the <code>str</code> type are byte representations (the encoded string). Under the hood, Python represents Unicode strings as either 16- or 32-bit integers, depending on how the Python interpreter was compiled.
cs: Python 2 přichází se dvěma různými druhy objektů, které mohou být použity k reprezentaci řetězců – <code>str</code> a <code>unicode</code>. Instance <code>unicode</code> se používají k vyjádření řetězců v Unikódu, zatímco instance typu <code>str</code> k bajtové reprezentaci (kódované řetězce). Pod kapotou Python uchovává unikódové řetězce jako 16 nebo 32bitová čísla, v závislosti na tom, jak je zkompilován interpretr jazyka Python.

note: (itstool) path: section/p
en: Unicode strings can be converted to 8-bit strings with <code>unicode.encode()</code>. Python’s 8-bit strings have a <code>str.decode()</code> method that interprets the string using the given encoding (that is, it is the inverse of the <code>unicode.encode()</code>):
cs: Unikódové řetězce je možné převést na 8bitové řetězce pomocí <code>unicode.encode()</code>. 8bitové řetězce v jazyce Python mají metodu <code>str.decode()</code>, které interpretuje řetězec pomocí zadaného kódování (tj. opak metody <code>unicode.encode()</code>):

note: (itstool) path: section/p
en: Unfortunately, Python 2.x allows you to mix <code>unicode</code> and <code>str</code> if the 8-bit string happened to contain only 7-bit (ASCII) bytes, but would get <sys>UnicodeDecodeError</sys> if it contained non-ASCII values.
cs: Bohužel, Python 2.x umožňuje míchat typy <code>unicode</code> a <code>str</code>, v případě, že 8bitový řetězec obsahuje jen 7bitové hodnoty (ASCII), ale když obsahuje jiné hodnoty (ne ASCII), obdržíte chybu <sys>UnicodeDecodeError</sys>.

note: (itstool) path: section/title
en: Strings in Python 3
cs: Řetězce v jazyce Python 3

note: (itstool) path: section/p
en: Since Python 3.0, all strings are stored as Unicode in an instance of the <code>str</code> type. Encoded strings on the other hand are represented as binary data in the form of instances of the bytes type. Conceptually, <code>str</code> refers to text, whereas bytes refers to data. Use <code>encode()</code> to go from <code>str</code> to <code>bytes</code>, and <code>decode()</code> to go from <code>bytes</code> to <code>str</code>.
cs: Od verze Python 3.0 jsou všechny řetězce uchovávány jako Unikód v instanci typu <code>str</code>. Kódované řetězce jsou na druhou stranu reprezentovány jako binární data ve formě instance typu <code>bytes</code>. Koncepčně <code>str</code> představuje řetězec, zatímco <code>bytes</code> data. K přechodu ze <code>str</code> na <code>bytes</code> použijte <code>encode()</code> a pro přechod z <code>bytes</code> na <code>str</code> zase <code>decode()</code>.

note: (itstool) path: section/p
en: In addition, it is no longer possible to mix Unicode strings with encoded strings, because it will result in a <code>TypeError</code>:
cs: Navíc již nadále není možné míchat unikódové řetězce s kódovanými řetězci, protože to způsobí chybu <code>TypeError</code>:

note: (itstool) path: section/title
en: Unicode in GTK+
cs: Unikód v GTK+

note: (itstool) path: section/p
en: GTK+ uses UTF-8 encoded strings for all text. This means that if you call a method that returns a string you will always obtain an instance of the <code>str</code> type. The same applies to methods that expect one or more strings as parameter, they must be UTF-8 encoded. However, for convenience PyGObject will automatically convert any unicode instance to str if supplied as argument:
cs: GTK+ používá pro veškerý text řetězce kódované v UTF-8. To znamená, že když zavoláte metodu vracející řetězec, vždy obdržíte instanci typu <code>str</code>. To stejné platí pro metody, které očekávají jeden nebo více řetězců jako parametr, musí být kódované v UTF-8. Nicméně, kvůli pohodlí objekt <code>PyGObject</code> automaticky převádí instance <code>unicode</code> na <code>str</code>, když jsou předány jako argument:

note: (itstool) path: section/p
en: Furthermore:
cs: Navíc:

note: (itstool) path: section/p
en: would return <code>False</code>, with the warning <code>__main__:1: UnicodeWarning: Unicode equal comparison failed to convert both arguments to Unicode - interpreting them as being unequal</code> (<code>Gtk.Label.get_text()</code> will always return a <code>str</code> instance; therefore, <code>txt</code> and <code>unicode_string</code> are not equal).
cs: by vrátilo <code>False</code> s varováním <code>__main__:1: UnicodeWarning: Unicode equal comparison failed to convert both arguments to Unicode - interpreting them as being unequal</code> (<code>Gtk.Label.get_text()</code> vždy vrátí instanci <code>str</code>, a proto si <code>txt</code> a <code>unicode_string</code> nejsou rovny).

note: (itstool) path: section/p
en: This is especially important if you want to internationalize your program using <link href="http://docs.python.org/library/gettext.html"><code>gettext</code></link>. You have to make sure that <code>gettext</code> will return UTF-8 encoded 8-bit strings for all languages.
cs: Toto je obzvláště důležité, kdy chcete svůj program internacionalizovat pomocí <link href="http://docs.python.org/library/gettext.html"><code>gettext</code></link>. Musíte zajistit, že <code>gettext</code> bude vracet pro všechny jazyky 8bitové řetězce kódované v UTF-8.

note: (itstool) path: section/p
en: In general it is recommended to not use <code>unicode</code> objects in GTK+ applications at all, and only use UTF-8 encoded <code>str</code> objects since GTK+ does not fully integrate with <code>unicode</code> objects.
cs: Obecně je doporučováno v aplikacích GTK+ vůbec nepoužívat objekty <code>unicode</code> a používat jen objekty <code>str</code> kódované v UTF-8, protože GTK+ nemá objekty <code>unicode</code> plně integrovány.

note: (itstool) path: section/p
en: String encoding is more consistent in Python 3.x because PyGObject will automatically encode/decode to/from UTF-8 if you pass a string to a method or a method returns a string. Strings, or text, will always be represented as instances of <code>str</code> only.
cs: Kódování řetězců je více konzistentní ve verzi Python 3.x, protože <code>PyGObject</code> automaticky kóduje/dekóduje do/z UTF-8, když předáváte řetězec metodě, nebo metoda vrací řetězec. Řetězce nebo texty budou vždy reprezentovány jen jako instance <code>str</code>.

note: (itstool) path: section/p
en: <link href="http://python-gtk-3-tutorial.readthedocs.org/en/latest/unicode.html">How To Deal With Strings - The Python GTK+ 3 Tutorial</link>
cs: <link href="http://python-gtk-3-tutorial.readthedocs.org/en/latest/unicode.html">Jak zacházet s řetězci – Výuka jazyka Python s GTK+ 3</link>

note: (itstool) path: info/desc
en: A "light switch" style toggle
cs: Přepínač ve stylu „posuvného vypínače“

note: (itstool) path: page/p
en: This switch toggles the title of the window.
cs: Tento vypínač přepíná název okna.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /*Signal handler for the "active" signal of the Switch*/
    static void
    activate_cb (GObject    *switcher,
                 GParamSpec *pspec,
                 gpointer    user_data)
    {
      GtkWindow *window = user_data;
    
      if (gtk_switch_get_active (GTK_SWITCH (switcher)))
        gtk_window_set_title (GTK_WINDOW (window), "Switch Example");
      else
        gtk_window_set_title (GTK_WINDOW (window), "");
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *grid;
      GtkWidget *window;
      GtkWidget *label;
      GtkWidget *switcher;
    
      /*Create a window with a set title and default size.
      Also, set a border width for the amount of space to leave
      inside the window*/
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Switch Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 300, 100);
      gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
      /*Create a label*/
      label = gtk_label_new ("Title");
    
      /*Create a switch with a default active state*/
      switcher = gtk_switch_new ();
      gtk_switch_set_active (GTK_SWITCH (switcher), TRUE);
    
      /*Create a grid and set the column spacing, attach the label and
      switch onto the grid and position them accordingly*/
      grid = gtk_grid_new();
      gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
      gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), switcher, 1, 0, 1, 1);
    
      /*Connecting the clicked signal to the callback function*/
      g_signal_connect (GTK_SWITCH (switcher), 
                        "notify::active", 
                        G_CALLBACK (activate_cb), 
                        window);
    
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Zpracuje signál "active" od widgetu Switch */
    static void
    activate_cb (GObject    *switcher,
                 GParamSpec *pspec,
                 gpointer    user_data)
    {
      GtkWindow *window = user_data;
    
      if (gtk_switch_get_active (GTK_SWITCH (switcher)))
        gtk_window_set_title (GTK_WINDOW (window), "Switch Example");
      else
        gtk_window_set_title (GTK_WINDOW (window), "");
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *grid;
      GtkWidget *window;
      GtkWidget *label;
      GtkWidget *switcher;
    
      /* Vytvoří okno s nasteveným názvem a výchozí velikostí.
         Rovněž nastaví šířku okraje, aby uvnitř okna bylo ponecháno
         více místa */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Switch Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 300, 100);
      gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
      /* Vytvoří popisek */
      label = gtk_label_new ("Title");
    
      /* Vytvoří vypínač s výchozím stavem */
      switcher = gtk_switch_new ();
      gtk_switch_set_active (GTK_SWITCH (switcher), TRUE);
    
      /* Vytvoří mřížku a nastaví rozestup sloupců, připojí popisek
         a přepínače do mřížky a správné je umístí */
      grid = gtk_grid_new();
      gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
      gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), switcher, 1, 0, 1, 1);
    
      /* Přípojí signál kliknutí na funkci zpětného volání */
      g_signal_connect (GTK_SWITCH (switcher), 
                        "notify::active", 
                        G_CALLBACK (activate_cb), 
                        window);
    
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: info/desc
en: A sliding switch that can be flipped on and off
cs: Posuvný vypínač, který se umí překlápět mezi stavy zapnuto a vypnuto

note: (itstool) path: page/p
en: A Switch has two positions, on and off. This example shows how you can use multiple switches together to control which <link xref="image.js">Image</link> is shown in the window. The pictures used in this example <link href="https://live.gnome.org/TarynFox?action=AttachFile&amp;do=get&amp;target=Animal+Photos.zip">can be downloaded here</link>.
cs: Vypínač má dvě polohy, zapnuto a vypnuto. V tomto příkladu si ukážeme, jak použít více vypínačů dohromady k řízení, který obrázek <link xref="image.js">Image</link> bude v okně zobrazen. Obrázky použité v tomto příkladu <link href="https://live.gnome.org/TarynFox?action=AttachFile&amp;do=get&amp;target=Animal+Photos.zip">můžete stáhnout zde</link>.

note: (itstool) path: note/p
en: The window will contain a "broken image" icon instead of a picture if picture files named <file>redfox.png</file>, <file>muteswan.png</file>, <file>fruitbat.png</file>, and <file>gentoopenguin.png</file> aren't in the same directory. You can change the code and the pictures around as you like, but the Creative Commons-licensed photos used in this example were taken from the following sources and cropped to 640x425:
cs: Okno může obsahovat ikonu „poškozený obrázek“ místo obrázku, když se soubor s obrázkem s názvem <file>redfox.png</file>, <file>muteswan.png</file>, <file>fruitbat.png</file> nebo <file>gentoopenguin.png</file> nenachází ve stejné složce, jako program. Kód a obrázky si můžete změnit dle své libosti. Fotografie s licencí Creative Commons použité v tomto příkladu byly pořízeny z následujících zdrojů a zmenšeny na 640 × 425 pixelů:

note: (itstool) path: item/p
en: <link href="http://en.wikipedia.org/wiki/File:Fuzzy_Freddy.jpg">Red fox photo</link> by Rob Lee, licensed <link href="http://creativecommons.org/licenses/by/2.0/deed.en">CC-By</link>
cs: <link href="http://en.wikipedia.org/wiki/File:Fuzzy_Freddy.jpg">Fotografie červené lišky</link> od Rob Lee, licencováno pod <link href="http://creativecommons.org/licenses/by/2.0/deed.en">CC-By</link>

note: (itstool) path: item/p
en: <link href="http://en.wikipedia.org/wiki/File:Pygoscelis_papua_-Nagasaki_Penguin_Aquarium_-swimming_underwater-8a.jpg">Gentoo penguin photo</link> by Ken Funakoshi, licensed <link href="http://creativecommons.org/licenses/by-sa/2.0/deed.en">CC-By-SA</link>
cs: <link href="http://en.wikipedia.org/wiki/File:Pygoscelis_papua_-Nagasaki_Penguin_Aquarium_-swimming_underwater-8a.jpg">Fotografie tučňáka Gentoo</link> od Ken Funakoshi, licencováno pod <link href="http://creativecommons.org/licenses/by-sa/2.0/deed.en">CC-By-SA</link>

note: (itstool) path: item/p
en: <link href="http://www.flickr.com/photos/shekgraham/127431519/in/photostream/">Fruit bat photo</link> by Shek Graham, licensed <link href="http://creativecommons.org/licenses/by/2.0/deed.en">CC-By</link>
cs: <link href="http://www.flickr.com/photos/shekgraham/127431519/in/photostream/">Fotografie kaloně</link> od Shek Graham, licencováno pod <link href="http://creativecommons.org/licenses/by/2.0/deed.en">CC-By</link>

note: (itstool) path: item/p
en: <link href="http://commons.wikimedia.org/wiki/File:Mute_Swan-Mindaugas_Urbonas.jpg">Mute swan photo</link> by Mindaugas Urbonas, licensed <link href="http://creativecommons.org/licenses/by-sa/2.5/deed.en">CC-By-SA</link>
cs: <link href="http://commons.wikimedia.org/wiki/File:Mute_Swan-Mindaugas_Urbonas.jpg">Fotografie mlčící labutě</link> od Mindaugas Urbonas, licencováno pod <link href="http://creativecommons.org/licenses/by-sa/2.5/deed.en">CC-By-SA</link>

note: (itstool) path: note/p
en: Photo credits and licensing information are shown in the application's <link xref="aboutdialog.js">AboutDialog</link>. Always remember to credit the original artist when using <link href="http://creativecommons.org">Creative Commons-licensed works!</link>
cs: Informace o zásluhách a licencích vztahujících se k fotografiím jsou zobrazeny v okně <link xref="aboutdialog.js">AboutDialog</link>. Vždy, když používáte <link href="http://creativecommons.org">práce licencované pod Creative Commons</link>, pamatujte na zásluhy původních autorů!

note: (itstool) path: section/code
en: 
    const SwitchExample = new Lang.Class({
        Name: 'Switch Example',
    
        // Create the application itself
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsswitch',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Connect 'activate' and 'startup' signals to the callback functions
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Callback function for 'activate' signal presents window when active
        _onActivate: function() {
            this._window.present();
        },
    
        // Callback function for 'startup' signal creates the menu and builds the UI
        _onStartup: function() {
            this._initMenus();
            this._buildUI ();
        },
cs: 
    const SwitchExample = new Lang.Class({
        Name: 'Switch Example',
    
        // Vytvoří vlastní aplikaci
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsswitch',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Připojí signály "activate" a "startup" k funkcím zpětného volání
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate: function() {
            this._window.present();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function() {
            this._initMenus();
            this._buildUI ();
        },

note: (itstool) path: section/p
en: All the code for this sample goes in the SwitchExample class. The above code creates a <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> for our widgets and window to go in.
cs: Všechen kód této ukázky je ve třídě <code>SwitchExample</code>. Výše uvedený kód vytvoří <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> pro naše widgety a okno, ve kterém budou.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI: function() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Animal Creator"});
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Animal Creator"});

note: (itstool) path: section/title
en: Creating the switches
cs: Vytvoření vypínačů

note: (itstool) path: section/code
en: 
            // Create the image widget and set its default picture
            this._image = new Gtk.Image ({file: "redfox.png"});
cs: 
            // Vytvoří widget Image a nastaví jeho výchozí obrázek
            this._image = new Gtk.Image ({file: "redfox.png"});

note: (itstool) path: section/p
en: We first create the <link xref="image.js">Image</link> that the switches will control. Remember that a file named <file>redfox.png</file> needs to be in the same directory as this application.
cs: Neprve vytvoříme <link xref="image.js">Image</link>, který budou vypínače řídit. Pamatujte, že soubor s názvem <file>redfox.png</file> musí být ve stejné složce, jako tato aplikace.

note: (itstool) path: section/code
en: 
            // Create a label for the first switch
            this._flyLabel = new Gtk.Label ({
                label: "Make it fly",
                margin_right: 30});
    
            // Create the first switch and set its default position
            this._flySwitch = new Gtk.Switch ({active: false});
            this._flySwitch.connect ('notify::active', Lang.bind (this, this._switchFlip));
    
            // Create a label for the second switch
            this._birdLabel = new Gtk.Label ({
                label: "Make it a bird",
                margin_right: 30});
    
            // Create the second switch
            this._birdSwitch = new Gtk.Switch ({active: false});
            this._birdSwitch.connect ('notify::active', Lang.bind (this, this._switchFlip));
cs: 
            // Vytvoří popisek pro první vypínač
            this._flyLabel = new Gtk.Label ({
                label: "Make it fly",
                margin_right: 30});
    
            // Vytvoří první vypínač a nastaví jeho výchozí polohu
            this._flySwitch = new Gtk.Switch ({active: false});
            this._flySwitch.connect ('notify::active', Lang.bind (this, this._switchFlip));
    
            // Vytvoří popisek pro druhý vypínač
            this._birdLabel = new Gtk.Label ({
                label: "Make it a bird",
                margin_right: 30});
    
            // Vytvoří druhý vypínač
            this._birdSwitch = new Gtk.Switch ({active: false});
            this._birdSwitch.connect ('notify::active', Lang.bind (this, this._switchFlip));

note: (itstool) path: section/p
en: We use a <link xref="label.js">Label</link> to mark each Switch, and give them a bit of a margin on the right so that they aren't crammed right next to the Switches. After that we create the Switches, and set them to be switched off by default.
cs: Použijeme <link xref="label.js">Label</link> k označení každého z vypínačů a necháme mu malý okraj napravo, aby text nebyl nalepený hned na vypínač. Po té vytvoříme vypínače a nastavíme je na vypnuté ve výchozím stavu.

note: (itstool) path: section/p
en: The signal a switch sends out when it's flipped on or off is called notify::active. After we create each switch, we connect its notify::active signal to a function called _switchFlip. If you have multiple switches that each do something different, you might want to connect them to different functions, but here they're both used for the same thing: To control what picture's displayed by _image.
cs: Signál, který vypínač vyšle při svém přepnutí do polohy vypnuto nebo zapnuto se nazývá <code>"notify::active"</code>. Po vytvoření každého z vypínačů napojíme tento signál na funkci nazvanou <code>_switchFlip</code>. Když máte více vypínačů, kdy každý dělá něco jiného, můžete je chtít napojit na různé funkce, ale zde jsou oba použity pro stejnou věc: řízení pomocí <code>_image</code>, který obrázek se zobrazí.

note: (itstool) path: section/code
en: 
            // Create a grid for the labels and switches beneath the picture
            this._UIGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_top: 20});
    
            // Attach the labels and switches to that grid
            this._UIGrid.attach (this._flyLabel, 0, 0, 1, 1);
            this._UIGrid.attach (this._flySwitch, 1, 0, 1, 1);
            this._UIGrid.attach (this._birdLabel, 0, 1, 1, 1);
            this._UIGrid.attach (this._birdSwitch, 1, 1, 1, 1);
    
            // Create a master grid to put both the UI and the picture into
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Attach the picture and the UI grid to the master grid
            this._mainGrid.attach (this._image, 0, 0, 1, 1);
            this._mainGrid.attach (this._UIGrid, 0, 1, 1, 1);
cs: 
            // Vytvoří mřížku pro popisky a vypínače pod obrázkem
            this._UIGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_top: 20});
    
            // Připojí popisky a vypínače do mřížky
            this._UIGrid.attach (this._flyLabel, 0, 0, 1, 1);
            this._UIGrid.attach (this._flySwitch, 1, 0, 1, 1);
            this._UIGrid.attach (this._birdLabel, 0, 1, 1, 1);
            this._UIGrid.attach (this._birdSwitch, 1, 1, 1, 1);
    
            // Vytvoří hlavní mřížku pro vložení obrázku a  mřížky s ovládacími prvky
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Připojí obrázek a mřížku s ovládacími prvky do hlavní mřížky
            this._mainGrid.attach (this._image, 0, 0, 1, 1);
            this._mainGrid.attach (this._UIGrid, 0, 1, 1, 1);

note: (itstool) path: section/p
en: We create a <link xref="grid.js">Grid</link> for the Labels and Switches first, so that we can organize them in a 2x2 layout with a margin between it and the Image. Then we put that Grid into a larger 2x1 Grid that has the Image on top, and the Grid with the Labels and Switches on the bottom.
cs: Jako první vytvoříme <link xref="grid.js">Grid</link> pro popisky a vypínače, abychom je uspořádali do matice 2 × 2 s okrajem mezi nimi a obrázkem. Pak tuto mřížku vložíme do větší mřížky 2 × 1, která má nahoře obrázek a dole mřížku s popisky a vypínači.

note: (itstool) path: section/code
en: 
            // Add the master grid to the window
            this._window.add (this._mainGrid);
    
            // Show the window and all child widgets
            this._window.show_all();
        },
cs: 
            // Přidá hlavní mřížku do okna
            this._window.add (this._mainGrid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        },

note: (itstool) path: section/title
en: Function which handles the switches being flipped
cs: Funkce, která obsluhuje situaci, kdy je vypínač přepnut

note: (itstool) path: section/code
en: 
        _switchFlip: function() {
    
            // Change the picture depending on which switches are flipped
            if (this._flySwitch.get_active()) {
    
                if (this._birdSwitch.get_active()) this._image.set_from_file ("muteswan.png");
    
                else this._image.set_from_file ("fruitbat.png");
            }
    
            else {
    
                if (this._birdSwitch.get_active()) this._image.set_from_file ("gentoopenguin.png");
    
                else this._image.set_from_file ("redfox.png");
    
            }
    
        },
cs: 
        _switchFlip: function() {
    
            // Změní obrázek podle toho, v jaké poloze je vypínač
            if (this._flySwitch.get_active()) {
    
                if (this._birdSwitch.get_active()) this._image.set_from_file ("muteswan.png");
    
                else this._image.set_from_file ("fruitbat.png");
            }
    
            else {
    
                if (this._birdSwitch.get_active()) this._image.set_from_file ("gentoopenguin.png");
    
                else this._image.set_from_file ("redfox.png");
    
            }
    
        },

note: (itstool) path: section/p
en: Each time a Switch is flipped, this function checks to see which of the two Switches are active afterwards, using the Switches' built-in get_active() function. It then changes the Image accordingly. You can change the filenames around as you like, so long as you have pictures to go with them.
cs: Pokaždé, když je přepnut vypínač, tato funkce zkontroluje, které ze dvou vypínačů jsou zapnuté, za použití funkce <code>get_active()</code>, která je součástí widgetu <code>Switch</code>. Pak příslušně změní obrázek. Názvy souborů si můžete měnit dle libosti, čímž se patřičně změní použité obrázky.

note: (itstool) path: section/title
en: Creating the AboutDialog
cs: Vytvoření AboutDialog

note: (itstool) path: section/code
en: 
        _initMenus: function() {
    
            // Build the application's menu so we can have an "About" button
            let menu = new Gio.Menu();
            menu.append("About", 'app.about');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            // Bind the "About" button to the _showAbout() function
            let aboutAction = new Gio.SimpleAction ({ name: 'about' });
            aboutAction.connect('activate', Lang.bind(this,
                function() {
                    this._showAbout();
                }));
            this.application.add_action(aboutAction);
    
            // Bind the "Quit" button to the function that closes the window
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', Lang.bind(this,
                function() {
                    this._window.destroy();
                }));
            this.application.add_action(quitAction);
        },
cs: 
        _initMenus: function() {
    
            // Sestaví aplikační nabídku, takže můžeme mít volby About a Quit
            let menu = new Gio.Menu();
            menu.append("About", 'app.about');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            // Napojí akci "about" na funkci _showAbout()
            let aboutAction = new Gio.SimpleAction ({ name: 'about' });
            aboutAction.connect('activate', Lang.bind(this,
                function() {
                    this._showAbout();
                }));
            this.application.add_action(aboutAction);
    
            // Napojí akci "quit" na funkci, která zavře okno
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', Lang.bind(this,
                function() {
                    this._window.destroy();
                }));
            this.application.add_action(quitAction);
        },

note: (itstool) path: section/p
en: The first step is building the <link xref="gmenu.js">GMenu</link> that the "About" button goes into. This is the menu that appears when you click the application's name in the upper-left corner of the screen, next to the Activities menu. Our menu only has two options in it: About, and Quit.
cs: Prvním krokem je sestavení <link xref="gmenu.js">GMenu</link>, do kterého položka <gui>About</gui> patří. Jedná se o nabídku, která se objeví, když kliknete na název aplikace v levém horním rohu obrazovky, vedle nabídky <gui>Činnosti</gui>. Naše nabídka má jen dvě položky: About a Quit.

note: (itstool) path: section/code
en: 
        _showAbout: function () {
    
            // String arrays of the names of the people involved in the project
            var artists = ['Rob Lee http://en.wikipedia.org/wiki/File:Fuzzy_Freddy.jpg', 'Ken Funakoshi http://en.wikipedia.org/wiki/File:Pygoscelis_papua_-Nagasaki_Penguin_Aquarium_-swimming_underwater-8a.jpg', 'Shek Graham http://www.flickr.com/photos/shekgraham/127431519/in/photostream/', 'Mindaugas Urbonas http://commons.wikimedia.org/wiki/File:Mute_Swan-Mindaugas_Urbonas.jpg'];
            var authors = ["GNOME Documentation Team"];
            var documenters = ["GNOME Documentation Team"];
    
            // Create the About dialog
            let aboutDialog = new Gtk.AboutDialog({
                title: "AboutDialog Example",
                program_name: "Animal Creator",
                copyright: "Copyright \xa9 2012 GNOME Documentation Team\n\nRed fox photo licensed CC-By by Rob Lee\nGentoo penguin photo licensed CC-By-SA by Ken Funakoshi\nFruit bat photo licensed CC-By by Shek Graham\nMute swan photo licensed CC-By-SA by Mindaugas Urbonas\nLinks to the originals are available under Credits.\n\nHave you hugged a penguin today?",
                artists: artists,
                authors: authors,
                documenters: documenters,
                website: "http://developer.gnome.org",
                website_label: "GNOME Developer Website" });
    
            // Attach the About dialog to the window
            aboutDialog.modal = true;
            aboutDialog.transient_for = this._window;
    
            // Show the About dialog
            aboutDialog.show();
    
            // Connect the Close button to the destroy signal for the dialog
            aboutDialog.connect('response', function() {
                aboutDialog.destroy();
            });
        }
    
    });
cs: 
        _showAbout: function () {
    
            // Pole řetězců se jmény lidí, kteří se na projektu podílejí
            var artists = ['Rob Lee http://en.wikipedia.org/wiki/File:Fuzzy_Freddy.jpg',
                           'Ken Funakoshi http://en.wikipedia.org/wiki/File:Pygoscelis_papua_-Nagasaki_Penguin_Aquarium_-swimming_underwater-8a.jpg',
                           'Shek Graham http://www.flickr.com/photos/shekgraham/127431519/in/photostream/',
                           'Mindaugas Urbonas http://commons.wikimedia.org/wiki/File:Mute_Swan-Mindaugas_Urbonas.jpg'];
            var authors = ["GNOME Documentation Team"];
            var documenters = ["GNOME Documentation Team"];
    
            // Vytvoří dialogové okno „O aplikaci“
            let aboutDialog = new Gtk.AboutDialog({
                title: "AboutDialog Example",
                program_name: "Animal Creator",
                copyright: "Copyright \xa9 2012 GNOME Documentation Team\n\nRed fox photo licensed CC-By by Rob Lee\nGentoo penguin photo licensed CC-By-SA by Ken Funakoshi\nFruit bat photo licensed CC-By by Shek Graham\nMute swan photo licensed CC-By-SA by Mindaugas Urbonas\nLinks to the originals are available under Credits.\n\nHave you hugged a penguin today?",
                artists: artists,
                authors: authors,
                documenters: documenters,
                website: "http://developer.gnome.org",
                website_label: "GNOME Developer Website" });
    
            // Připojí dialogové okno „O aplikaci“ k oknu
            aboutDialog.modal = true;
            aboutDialog.transient_for = this._window;
    
            // Zobrazí dialogové okno „O aplikaci“
            aboutDialog.show();
    
            // Napojí tlačítko Close na signál "destroy" pro dialogové okno
            aboutDialog.connect('response', function() {
                aboutDialog.destroy();
            });
        }
    
    });

note: (itstool) path: section/p
en: An <link xref="aboutdialog.js">AboutDialog</link> has a lot of different things you can set, to credit everyone who worked on the application and leave a note to whomever reads it. In this case, the copyright section contains our note and credits the original photographers, while the artists section shows you a list of the photographers with links to the original photos when you click the Credits button. The web URLs put after their names in the array turn their names into clickable links in the Credits section.
cs: Widget <link xref="aboutdialog.js">AboutDialog</link> má spoustu různých věcí, které můžete nastavit, abyste ocenili zásluhy každého, kdo na aplikaci pracoval, a nechali vzkaz komukoliv, kdo to bude číst. V tomto případě část s autorskými právy obsahuje naši poznámku a přičítá zásluhy původním fotografům, zatímco část s umělci, když kliknete na tlačítko <gui>Credits</gui>, uvádí seznam fotografů s odkazy na originální fotografie. Webová adresa URL vložená za jejich jména v poli způsobí, že jména budou v části <gui>Credists</gui> fungovat jako živé odkazy.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new SwitchExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new SwitchExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished SwitchExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci výsledné třídy SwitchExample a spustíme aplikaci.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class SwitchExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsswitch'
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal creates the menu and builds the UI
        _onStartup() {
            this._initMenus();
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Animal Creator"});
    
            // Create the image widget and set its default picture
            this._image = new Gtk.Image ({file: "redfox.png"});
    
            // Create a label for the first switch
            this._flyLabel = new Gtk.Label ({
                label: "Make it fly",
                margin_right: 30});
    
            // Create the first switch and set its default position
            this._flySwitch = new Gtk.Switch ({active: false});
            this._flySwitch.connect ('notify::active', this._switchFlip.bind(this));
    
            // Create a label for the second switch
            this._birdLabel = new Gtk.Label ({
                label: "Make it a bird",
                margin_right: 30});
    
            // Create the second switch
            this._birdSwitch = new Gtk.Switch ({active: false});
            this._birdSwitch.connect ('notify::active', this._switchFlip.bind(this));
    
            // Create a grid for the labels and switches beneath the picture
            this._UIGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_top: 20});
    
            // Attach the labels and switches to that grid
            this._UIGrid.attach (this._flyLabel, 0, 0, 1, 1);
            this._UIGrid.attach (this._flySwitch, 1, 0, 1, 1);
            this._UIGrid.attach (this._birdLabel, 0, 1, 1, 1);
            this._UIGrid.attach (this._birdSwitch, 1, 1, 1, 1);
    
            // Create a master grid to put both the UI and the picture into
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Attach the picture and the UI grid to the master grid
            this._mainGrid.attach (this._image, 0, 0, 1, 1);
            this._mainGrid.attach (this._UIGrid, 0, 1, 1, 1);
    
            // Add the master grid to the window
            this._window.add (this._mainGrid);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _switchFlip() {
    
            // Change the picture depending on which switches are flipped
            if (this._flySwitch.get_active()) {
    
                if (this._birdSwitch.get_active())
                    this._image.set_from_file ("muteswan.png");
                else
                    this._image.set_from_file ("fruitbat.png");
            } else {
    
                if (this._birdSwitch.get_active())
                    this._image.set_from_file ("gentoopenguin.png");
                else
                    this._image.set_from_file ("redfox.png");
            }
        }
    
        _initMenus() {
    
            // Build the application's menu so we can have an "About" button
            let menu = new Gio.Menu();
            menu.append("About", 'app.about');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            // Bind the "About" button to the _showAbout() function
            let aboutAction = new Gio.SimpleAction ({ name: 'about' });
            aboutAction.connect('activate', () =&gt; { this._showAbout(); });
            this.application.add_action(aboutAction);
    
            // Bind the "Quit" button to the function that closes the window
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
            this.application.add_action(quitAction);
        }
    
        _showAbout() {
    
            // String arrays of the names of the people involved in the project
            var artists = ['Rob Lee http://en.wikipedia.org/wiki/File:Fuzzy_Freddy.png', 'Ken Funakoshi http://en.wikipedia.org/wiki/File:Pygoscelis_papua_-Nagasaki_Penguin_Aquarium_-swimming_underwater-8a.png', 'Shek Graham http://www.flickr.com/photos/shekgraham/127431519/in/photostream/', 'Mindaugas Urbonas http://commons.wikimedia.org/wiki/File:Mute_Swan-Mindaugas_Urbonas.png'];
            var authors = ["GNOME Documentation Team"];
            var documenters = ["GNOME Documentation Team"];
    
            // Create the About dialog
            let aboutDialog = new Gtk.AboutDialog({
                title: "AboutDialog Example",
                program_name: "Animal Creator",
                copyright: "Copyright \xa9 2012 GNOME Documentation Team\n\nRed fox photo licensed CC-By by Rob Lee\nGentoo penguin photo licensed CC-By-SA by Ken Funakoshi\nFruit bat photo licensed CC-By by Shek Graham\nMute swan photo licensed CC-By-SA by Mindaugas Urbonas\nLinks to the originals are available under Credits.\n\nHave you hugged a penguin today?",
                artists: artists,
                authors: authors,
                documenters: documenters,
                website: "http://developer.gnome.org",
                website_label: "GNOME Developer Website" });
    
            // Attach the About dialog to the window
            aboutDialog.modal = true;
            aboutDialog.transient_for = this._window;
    
            // Show the About dialog
            aboutDialog.show();
    
            // Connect the Close button to the destroy signal for the dialog
            aboutDialog.connect('response', function() {
                aboutDialog.destroy();
            });
        }
    };
    
    // Run the application
    let app = new SwitchExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class SwitchExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jsswitch'
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._initMenus();
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 20,
                title: "Animal Creator"});
    
            // Vytvoří widget Image a nastaví jeho výchozí obrázek
            this._image = new Gtk.Image ({file: "redfox.png"});
    
            // Vytvoří popisek pro první vypínač
            this._flyLabel = new Gtk.Label ({
                label: "Make it fly",
                margin_right: 30});
    
            // Vytvoří první vypínač a nastaví jeho výchozí polohu
            this._flySwitch = new Gtk.Switch ({active: false});
            this._flySwitch.connect ('notify::active', Lang.bind (this, this._switchFlip));
    
            // Vytvoří popisek pro druhý vypínač
            this._birdLabel = new Gtk.Label ({
                label: "Make it a bird",
                margin_right: 30});
    
            // Vytvoří druhý vypínač
            this._birdSwitch = new Gtk.Switch ({active: false});
            this._birdSwitch.connect ('notify::active', this._switchFlip.bind(this));
    
            // Vytvoří mřížku pro popisky a vypínače pod obrázkem
            this._UIGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER,
                margin_top: 20});
    
            // Připojí popisky a vypínače do mřížky
            this._UIGrid.attach (this._flyLabel, 0, 0, 1, 1);
            this._UIGrid.attach (this._flySwitch, 1, 0, 1, 1);
            this._UIGrid.attach (this._birdLabel, 0, 1, 1, 1);
            this._UIGrid.attach (this._birdSwitch, 1, 1, 1, 1);
    
            // Vytvoří hlavní mřížku pro vložení obrázku a  mřížky s ovládacími prvky
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Připojí obrázek a mřížku s ovládacími prvky do hlavní mřížky
            this._mainGrid.attach (this._image, 0, 0, 1, 1);
            this._mainGrid.attach (this._UIGrid, 0, 1, 1, 1);
    
            // Přidá hlavní mřížku do okna
            this._window.add (this._mainGrid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _switchFlip() {
    
            // Změní obrázek podle toho, v jaké poloze je vypínač
            if (this._flySwitch.get_active()) {
    
                if (this._birdSwitch.get_active())
                    this._image.set_from_file ("muteswan.png");
                else
                    this._image.set_from_file ("fruitbat.png");
            } else {
    
                if (this._birdSwitch.get_active())
                    this._image.set_from_file ("gentoopenguin.png");
                else
                    this._image.set_from_file ("redfox.png");
            }
        }
    
        _initMenus() {
    
            // Sestaví aplikační nabídku, takže můžeme mít tlačítko „About“
            let menu = new Gio.Menu();
            menu.append("About", 'app.about');
            menu.append("Quit",'app.quit');
            this.application.set_app_menu(menu);
    
            // Napojí tlačítko „About“ na funkci _showAbout()
            let aboutAction = new Gio.SimpleAction ({ name: 'about' });
            aboutAction.connect('activate', () =&gt; { this._showAbout(); });
            this.application.add_action(aboutAction);
    
            // Napojí tlačítko „Quit“ na funkci, která zavírá okno
            let quitAction = new Gio.SimpleAction ({ name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
            this.application.add_action(quitAction);
        }
    
        _showAbout() {
    
            // Pole řetězců se jmény lidí, kteří se podílejí na projektu
            var artists = ['Rob Lee http://en.wikipedia.org/wiki/File:Fuzzy_Freddy.png', 'Ken Funakoshi http://en.wikipedia.org/wiki/File:Pygoscelis_papua_-Nagasaki_Penguin_Aquarium_-swimming_underwater-8a.png', 'Shek Graham http://www.flickr.com/photos/shekgraham/127431519/in/photostream/', 'Mindaugas Urbonas http://commons.wikimedia.org/wiki/File:Mute_Swan-Mindaugas_Urbonas.png'];
            var authors = ["GNOME Documentation Team"];
            var documenters = ["GNOME Documentation Team"];
    
            // Vytvoří dialogové okno „O aplikaci“
            let aboutDialog = new Gtk.AboutDialog({
                title: "AboutDialog Example",
                program_name: "Animal Creator",
                copyright: "Copyright \xa9 2012 GNOME Documentation Team\n\nRed fox photo licensed CC-By by Rob Lee\nGentoo penguin photo licensed CC-By-SA by Ken Funakoshi\nFruit bat photo licensed CC-By by Shek Graham\nMute swan photo licensed CC-By-SA by Mindaugas Urbonas\nLinks to the originals are available under Credits.\n\nHave you hugged a penguin today?",
                artists: artists,
                authors: authors,
                documenters: documenters,
                website: "http://developer.gnome.org",
                website_label: "GNOME Developer Website" });
    
            // Připojí dialogové okno „O aplikaci“ k oknu
            aboutDialog.modal = true;
            aboutDialog.transient_for = this._window;
    
            // Zobrazí dialogové okno „O aplikaci“
            aboutDialog.show();
    
            // Napojí tlačítko „Zavřít“ na signál "destroy" pro dialogové okno
            aboutDialog.connect('response', function() {
                aboutDialog.destroy();
            });
        }
    };
    
    // Spustí aplikaci
    let app = new SwitchExample ();
    app.application.run (ARGV);

note: (itstool) path: page/p
en: This Switch makes the title appears and disappear.
cs: Přepínač způsobující zobrazení a skrytí textu v záhlaví.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # a window
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Switch Example", application=app)
            self.set_default_size(300, 100)
            self.set_border_width(10)
    
            # a switch
            switch = Gtk.Switch()
            # turned on by default
            switch.set_active(True)
            # connect the signal notify::active emitted by the switch
            # to the callback function activate_cb
            switch.connect("notify::active", self.activate_cb)
    
            # a label
            label = Gtk.Label()
            label.set_text("Title")
    
            # a grid to allocate the widgets
            grid = Gtk.Grid()
            grid.set_column_spacing(10)
            grid.attach(label, 0, 0, 1, 1)
            grid.attach(switch, 1, 0, 1, 1)
    
            # add the grid to the window
            self.add(grid)
    
        # Callback function. Since the signal is notify::active
        # we need the argument 'active'
        def activate_cb(self, button, active):
            # if the button (i.e. the switch) is active, set the title
            # of the window to "Switch Example"
            if button.get_active():
                self.set_title("Switch Example")
            # else, set it to "" (empty string)
            else:
                self.set_title("")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # a window
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Switch Example", application=app)
            self.set_default_size(300, 100)
            self.set_border_width(10)
    
            # Vypínač
            switch = Gtk.Switch()
            # Nastaví výchozí stav na zapnuto
            switch.set_active(True)
            # Napojí signál notify::active vyslaný vypínačem
            # na funkci zpětného volání activate_cb
            switch.connect("notify::active", self.activate_cb)
    
            # Popisek
            label = Gtk.Label()
            label.set_text("Title")
    
            # Mřížka pro umístění widgetů
            grid = Gtk.Grid()
            grid.set_column_spacing(10)
            grid.attach(label, 0, 0, 1, 1)
            grid.attach(switch, 1, 0, 1, 1)
    
            # Přidá mřížku do okna
            self.add(grid)
    
        # Funkce zpětného volání. Protože signál je notify::active
        # nepotřebujeme argument 'active'
        def activate_cb(self, button, active):
            # Jestliže je vypínače aktivní (tj. zapnutý), nastavíme
            # záhlaví okna na "Switch Example"
            if button.get_active():
                self.set_title("Switch Example")
            # Jinak jej nastavíme na "" (prázdný řetězec)
            else:
                self.set_title("")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Switch widget
cs: Užitečné metody pro widget Switch

note: (itstool) path: section/p
en: In line 17 the signal <code>"notify::active"</code> is connected to the callback function <code>activate_cb()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 17 je signál <code>"notify::active"</code> napojen na funkci zpětného volání <code>activate_cb()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: page/p
en: This Switch toggles the title.
cs: Tento přepínač přepíná název.

note: (itstool) path: info/desc
en: Widget which displays a GtkTextBuffer
cs: Widget, který zobrazuje GtkTextBuffer

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

note: (itstool) path: note/p
en: If we press "enter", we have a new line.
cs: Když zmáčkneme <key>Enter</key>, dostaneme nový řádek.

note: (itstool) path: note/p
en: If we press "enter" more times then there are lines in the default sized window, then a vertical scrollbar appears.
cs: Když zmáčkneme <key>Enter</key> vícekrát, než je počet řádků ve výchozí velikosti okna, objeví se svislý posuvník.

note: (itstool) path: note/p
en: If we write a long sentence, the text will wrap breaking lines between words.
cs: Když napíšeme dlouhou větu, text se zalomí mezi slovy.

note: (itstool) path: note/p
en: If we have a loooooooooooooooooooooooooooooooooooong (that was long) word, a* horizontal scrollbar will appear.
cs: Když napíšeme dlouhéééééééééééééééééééééééééééééééé (to bylo ale dlouhé) slovo, objeví se vodorovný posuvník.

note: (itstool) path: page/p
en: This is an example of Gtk.TextView
cs: Zde je příklad Gtk.TextView

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      /* Declare variables */
      GtkWidget *window;
      GtkWidget *text_view;
      GtkWidget *scrolled_window;
    
      GtkTextBuffer *buffer;
    
    
      /* Create a window with a title, and a default size */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "TextView Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 220, 200);
    
    
      /* The text buffer represents the text being edited */
      buffer = gtk_text_buffer_new (NULL);
      
    
      /* Text view is a widget in which can display the text buffer. 
       * The line wrapping is set to break lines in between words.
       */
      text_view = gtk_text_view_new_with_buffer (buffer);
      gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD); 
    
    
      /* Create the scrolled window. Usually NULL is passed for both parameters so 
       * that it creates the horizontal/vertical adjustments automatically. Setting 
       * the scrollbar policy to automatic allows the scrollbars to only show up 
       * when needed. 
       */
      scrolled_window = gtk_scrolled_window_new (NULL, NULL);
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), 
                                      GTK_POLICY_AUTOMATIC, 
                                      GTK_POLICY_AUTOMATIC); 
      /* The function directly below is used to add children to the scrolled window 
       * with scrolling capabilities (e.g text_view), otherwise, 
       * gtk_scrolled_window_add_with_viewport() would have been used
       */
      gtk_container_add (GTK_CONTAINER (scrolled_window), 
                                             text_view);
      gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 5);
     
      
      gtk_container_add (GTK_CONTAINER (window), scrolled_window);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      /* Deklarace proměnných */
      GtkWidget *window;
      GtkWidget *text_view;
      GtkWidget *scrolled_window;
    
      GtkTextBuffer *buffer;
    
    
      /* Vytvoří okno s názvem a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "TextView Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 220, 200);
    
    
      /* Textová vyrovnávací paměť představující upravovaný text */
      buffer = gtk_text_buffer_new (NULL);
      
    
      /* TextView je widget, ve kterém můžeme zobrazit textovou vyrovnávací paměť. 
       * Zalamování řádků je nastaveno na zalamování mezi slovy.
       */
      text_view = gtk_text_view_new_with_buffer (buffer);
      gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD); 
    
    
      /* Vytvoří okno s posuvníky. Obvykle se oběma parametrům předává NULL, takže 
       * se vytvoření svislého/vodorovného posuvníku automaticky přizpůsobí. Nastavení 
       * pravidel pro posuvníky na automatiku umožní posuvníkům zobrazit se, jen když 
       * je to zapotřebí. 
       */
      scrolled_window = gtk_scrolled_window_new (NULL, NULL);
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), 
                                      GTK_POLICY_AUTOMATIC, 
                                      GTK_POLICY_AUTOMATIC); 
      /* Následující funkce se používá k přidání do okna s posuvníky potomků
       * se schopností posouvání (např. text_view), jinak by se muselo 
       * použít gtk_scrolled_window_add_with_viewport()
       */
      gtk_container_add (GTK_CONTAINER (scrolled_window), 
                                             text_view);
      gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 5);
     
      
      gtk_container_add (GTK_CONTAINER (window), scrolled_window);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: info/desc
en: A multiline text editor
cs: Víceřádkový textový editor

note: (itstool) path: page/p
en: A TextView is really (or at least usually) a nested set of three objects.
cs: TextView (textové zobrazení) je ve skutečnosti, nebo alespoň většinou, sada tří vnořených objektů.

note: (itstool) path: item/p
en: At the bottom there is a <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gtk.TextBuffer.html">TextBuffer</link>. This holds the text itself.
cs: Vespod je <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gtk.TextBuffer.html">TextBuffer</link>. Ten uchovává vlastní text.

note: (itstool) path: item/p
en: In the middle there is the <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gtk.TextView.html">TextView</link>, which is a widget that lets you see and edit the text in the buffer. It automatically resizes itself depending on how much text there is.
cs: Uprostřed je <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gtk.TextView.html">TextView</link>, což je widget, který umožňuje zobrazit a upravovat text z vyrovnávací paměti. Automaticky mění svoji velikost v závislosti na množství textu v něm.

note: (itstool) path: item/p
en: Since the automatic resizing can make a TextView unwieldy, you normally place it inside of a ScrolledWindow. Despite the name, it's not an actual window in terms of having a title bar and an X button; it's a widget you put on the application you're making, which acts like a window onto a more manageable chunk of a TextView. If the text in the buffer is too big to fit, scrollbars will appear.
cs: Protože automatické změny mohou učinit <code>TextView</code> neprakticky použitelným, je běžnou praxí umístit jej do widgetu <code>ScrolledWindow</code>. Navzdory výrazu „window“ v názvu se nejedná o běžně známe okno se záhlavím a tlačítkem <gui>×</gui>, ale o widget, který vložený do aplikace bude fungovat jako okno do lépe zvládnutého zobrazení textu. Když bude text ve vyrovnávací paměti delší, než se vleze, objeví se posuvníky.

note: (itstool) path: page/p
en: If you want to change what text is displayed in the TextView, you act on the TextBuffer, since it's what actually holds the text. The same goes for if you want to see what text someone typed in. This sample application lets you talk to a (make-believe) penguin, and checks the TextBuffer to see if you typed the word "fish" anywhere in it.
cs: Když chcete změnit text, který je v <code>TextView</code> zobrazen, musíte pracovat s objektem <code>TextBuffer</code>, protože právě v něm je text uložen. To samé platí, když chcete vidět, co někdo do něj napsal. Tato ukázková aplikace umožňuje promluvit si se (smyšleným) tučňákem a kontroluje <code>TextBuffer</code>, aby zjistila, jestli jste někde nenapsali slovo „fish“ (ryba).

note: (itstool) path: note/p
en: Real-life penguin populations are declining fast, because climate change is melting the ice that they live on and killing the fish that they eat. If you'd like to play a (somewhat silly) GNOME game based on this premise, take a look at <link href="http://pingus.seul.org/">Pingus</link>.
cs: Ve skutečném světe populace tučňáků rychle klesá, protože změny klimatu způsobují tání ledovců, na kterých žijí, a zabíjí ryby, které jí. Jestli si chcete v GNOME zahrát (poněkud bláznivou) hru založenou na tomto předpokladu, podívejte se na <link href="http://pingus.seul.org/">Pingus</link>.

note: (itstool) path: section/code
en: 
    const TextViewExample = new Lang.Class ({
        Name: 'TextView Example',
    
        // Create the application itself
        _init: function () {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jstextview' });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', Lang.bind(this, this._onActivate));
            this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate: function () {
            this._window.present ();
        },
    
        // Callback function for 'startup' signal builds the UI
        _onStartup: function () {
            this._buildUI ();
        },
cs: 
    const TextViewExample = new Lang.Class ({
        Name: 'TextView Example',
    
        // Vytvoří vlastní aplikaci
        _init: function () {
            this.application = new Gtk.Application ({
                application_id: 'org.example.jstextview' });
    
            // Připojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', Lang.bind(this, this._onActivate));
            this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate: function () {
            this._window.present ();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function () {
            this._buildUI ();
        },

note: (itstool) path: section/p
en: All the code for this sample goes in the TextViewExample class. The above code creates a <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> for our widgets and window to go in.
cs: Všechen kód této ukázky je ve třídě <code>TextViewExample</code>. Výše uvedený kód vytvoří <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> pro naše widgety a okno, ve kterém budou.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI: function () {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Talk to a Penguin",
                default_height: 400,
                default_width: 440,
                border_width: 20 });
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function () {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Talk to a Penguin",
                default_height: 400,
                default_width: 440,
                border_width: 20 });

note: (itstool) path: section/title
en: Creating the TextView
cs: Vytvoření TextView

note: (itstool) path: section/code
en: 
            // Create a label for the penguin to talk to you
            this._penguin = new Gtk.Label ({
                height_request: 180,
                width_request: 400,
                label: "Squaaaak?",
                wrap: true });
cs: 
            // Vytvoří popisek přes který k vám bude promlouvat tučňák
            this._penguin = new Gtk.Label ({
                height_request: 180,
                width_request: 400,
                label: "Squaaaak?",
                wrap: true });

note: (itstool) path: section/p
en: Our first step in this example is to create the <link xref="label.js">Label</link> that the penguin will use to talk to you. We set the text in it to wrap by setting its wrap property to true, but we'll use a different method on the TextView itself that allows for more fine-grained control.
cs: Naším prvním krokem v tomto příkladu bude vytvořit <link xref="label.js">Label</link>, který tučňák používá k proslovům. Pomocí nastavení vlastnosti <code>wrap</code> na <code>true</code> zajistíme, že text se může zalamovat, ale u widgetu <code>TextView</code> použijeme jinou metodu, která nám umožní jemnější řízení.

note: (itstool) path: section/code
en: 
            // Create a textview for you to talk to the penguin
            this.buffer = new Gtk.TextBuffer();
            this._textView = new Gtk.TextView ({
                buffer: this.buffer,
                editable: true,
                wrap_mode: Gtk.WrapMode.WORD });
cs: 
            // Vytvoří textové zobrazení, přes které můžete mluvit na tučňáka
            this.buffer = new Gtk.TextBuffer();
            this._textView = new Gtk.TextView ({
                buffer: this.buffer,
                editable: true,
                wrap_mode: Gtk.WrapMode.WORD });

note: (itstool) path: section/p
en: Our first step is to create a TextBuffer to put the words into. After that we create the TextView, and tell it to use the TextBuffer we created as its buffer. We also set it to be editable, since we want to be able to type new things in.
cs: Jako první krok je vytvořen <code>TextBuffer</code> pro vkládání slov. Po té zde vytvoříme <code>TextView</code> a řekneme mu, že má používat právě vytvořený <code>TextBuffer</code>. Rovněž se nastaví jako upravitelný, protože chceme mít možnost do něj psát nové věci.

note: (itstool) path: section/p
en: The wrap_mode property lets you select from four different <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gtk.WrapMode.html">WrapModes</link>. Gtk.WrapMode.CHAR, for instance, starts wrapping around in the middle of a word if you keep typing when it gets to the edge. Most people are probably used to Gtk.WrapMode.WORD, which will automatically put the word you're typing on the next line if it gets to be too long.
cs: Vlastnost <code>wrap_mode</code> dává možnost vybrat si ze čtyř různých <link href="http://www.roojs.org/seed/gir-1.2-gtk-3.0/gjs/Gtk.WrapMode.html">režimů zalamování</link>. Například <code>Gtk.WrapMode.CHAR</code> způsobí zalomení uprostřed slova, když budete pokračovat v psaní za okraj. Většina lidí pravděpodobně použije <code>Gtk.WrapMode.WORD</code>, který automaticky přesune psané slovo na další řádek, když je příliš dlouhé.

note: (itstool) path: section/code
en: 
            // Create a "scrolled window" to put your textview in so it will scroll
            this._scrolled = new Gtk.ScrolledWindow ({
                hscrollbar_policy: Gtk.PolicyType.AUTOMATIC,
                vscrollbar_policy: Gtk.PolicyType.AUTOMATIC,
                shadow_type: Gtk.ShadowType.ETCHED_IN,
                height_request: 180,
                width_request: 400, });
    
            // Put the textview into the scrolled window
            this._scrolled.add_with_viewport (this._textView);
cs: 
            // Vytvoří okno s posuvníky pro vložení textového zobrazení, aby
            // mohlo posouvat svůj obsah
            this._scrolled = new Gtk.ScrolledWindow ({
                hscrollbar_policy: Gtk.PolicyType.AUTOMATIC,
                vscrollbar_policy: Gtk.PolicyType.AUTOMATIC,
                shadow_type: Gtk.ShadowType.ETCHED_IN,
                height_request: 180,
                width_request: 400, });
    
            // Vloží textové zobrazení do okna s posuvníky
            this._scrolled.add_with_viewport (this._textView);

note: (itstool) path: section/p
en: Here we create a ScrolledWindow, and set it to automatically scroll if it gets to be too big horizontally or vertically. We also give it a nice-looking ETCHED_IN border. After that, we put our TextView inside, and tell the ScrolledWindow to give us a viewport onto it.
cs: Zde vytvoříme okno s posuvníky a nastavíme jej, aby automaticky poskytlo posuvníky, když dostaneme příliš velký obsah, ať už vodorovně nebo svisle. Rovněž získáme hezky vypadající okraj <code>ETCHED_IN</code> (prohnutý). Po té dovnitř vložíme <code>TextView</code> a řekneme oknu s posuvníky, aby nám pro něj poskytlo pohled.

note: (itstool) path: section/code
en: 
            // Create a grid to organize them in
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Put the label and textview in the grid one on top of the other
            this._grid.attach (this._penguin, 0, 0, 1, 1);
            this._grid.attach (this._scrolled, 0, 1, 1, 1);
cs: 
            // Vytvoří mřížku pro uspořádání widgetů
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Vloží popisek a textové zobrazení do mřížky, jeden nad druhý
            this._grid.attach (this._penguin, 0, 0, 1, 1);
            this._grid.attach (this._scrolled, 0, 1, 1, 1);

note: (itstool) path: section/p
en: The first <link xref="grid.js">Grid</link> we create only has the Label and the ScrolledWindow inside it.
cs: První widget <link xref="grid.js">Grid</link>, který jsme vytvořili, má uvnitř jen popisek a okno s posuvníky.

note: (itstool) path: section/code
en: 
            // Create a button to send your message to the penguin
            this._send = new Gtk.Button ({
                halign: Gtk.Align.END,
                margin_top: 20,
                label: "Send" });
            this._send.connect ('clicked', Lang.bind (this, this._chat));
    
            // Create a grid that will have the other grid on top and the button on bottom
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Add the other grid and the button to the main grid
            this._mainGrid.attach (this._grid, 0, 0, 1, 1);
            this._mainGrid.attach (this._send, 0, 1, 1, 1);
cs: 
            // Vytvoří tlačítko pro odeslání vaší zprávy tučňákovi
            this._send = new Gtk.Button ({
                halign: Gtk.Align.END,
                margin_top: 20,
                label: "Send" });
            this._send.connect ('clicked', Lang.bind (this, this._chat));
    
            // Vytvoří mřížku pro poddružnou mřížku nahoře a tlačítko dole
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Přidá poddružnou mřížku a tlačítko do hlavní mřížky
            this._mainGrid.attach (this._grid, 0, 0, 1, 1);
            this._mainGrid.attach (this._send, 0, 1, 1, 1);

note: (itstool) path: section/p
en: We create a <link xref="button.js">Button</link> to send your message to the penguin, and a new Grid that has the other one on top and the Button on the bottom. The Button has a margin on top, so that it isn't squished up against the ScrolledWindow.
cs: Vytvoříme widget <link xref="button.js">Button</link>, který odešle vaši zprávu tučňákovi, a mřížku, která bude nahoře obsahovat předchozí mřížku a dole tlačítko. Tlačítko má nahoře okraj, díky čemuž se nelepí na okno s posuvníky.

note: (itstool) path: section/code
en: 
            // Attach the main grid to the window
            this._window.add (this._mainGrid);
    
            // Show the window and all child widgets
            this._window.show_all();
        },
cs: 
            // Připojí hlavní mřížku do okna
            this._window.add (this._mainGrid);
    
            // Zobrazení okno a všechny jeho synovské widgety
            this._window.show_all();
        },

note: (itstool) path: section/p
en: Finally, we attach the main Grid to the window, then we tell the window and everything inside it to become visible when the application is run.
cs: Nakonec připojíme hlavní mřížku do okna, kterému řekneme, aby sebe a vše v něm nastavilo jako viditelné, když se spustí aplikace.

note: (itstool) path: section/title
en: Function which handles the penguin's response
cs: Funkce, která se stará o odpovědi tučňáka

note: (itstool) path: section/code
en: 
        _chat: function () {
    
            // Create a random number to determine what the penguin says
            this.number = Math.floor ((Math.random() * 3) + 1);
    
            // Did you actually say anything?
            if (this.buffer.text) {
    
                // Did you mention fish?
                if (this.buffer.text.match (/fish/gi)) {
    
                    // Have the penguin squaak about fish
                    if (this.number == 1)
                        this._penguin.set_label ("FISH!");
    
                    else if (this.number == 2)
                        this._penguin.set_label ("Fish fish fish fish. Fish!");
    
                    else
                        this._penguin.set_label ("Fish? Fish fish fish. Fish fish. FISH!");
    
                }
    
                // I guess you didn't mention fish
                else {
    
                    // Have the penguin talk about penguinny stuff
                    if (this.number == 1)
                        this._penguin.set_label ("SQUAAK!");
    
                    else if (this.number == 2)
                        this._penguin.set_label ("Ork ork ork ork squaak. Squaak squaak! *waves flippers*");
    
                    else
                        this._penguin.set_label ("Ork ork ork ork ork?");
    
                }
    
            }
    
            // Clear the buffer
            this.buffer.text = "";
    
            // Give focus back to the textview so you don't have to click it again
            this._textView.has_focus = true;
    
        }
    
    });
cs: 
        _chat: function () {
    
            // Vytvoří náhodné číslo, které určí, co tučňák řekne
            this.number = Math.floor ((Math.random() * 3) + 1);
    
            // Řekli jste právě něco?
            if (this.buffer.text) {
    
                // Zmínili jste rybu?
                if (this.buffer.text.match (/fish/gi)) {
    
                    // Tučňák musí zaskřehovat o rybě
                    if (this.number == 1)
                        this._penguin.set_label ("FISH!");
    
                    else if (this.number == 2)
                        this._penguin.set_label ("Fish fish fish fish. Fish!");
    
                    else
                        this._penguin.set_label ("Fish? Fish fish fish. Fish fish. FISH!");
    
                }
    
                // Myslím, že jsem se nezmínil o rybě
                else {
    
                    // Tučňák pokecá o všedních záležitostech tučňáků
                    if (this.number == 1)
                        this._penguin.set_label ("SQUAAK!");
    
                    else if (this.number == 2)
                        this._penguin.set_label ("Ork ork ork ork squaak. Squaak squaak! *waves flippers*");
    
                    else
                        this._penguin.set_label ("Ork ork ork ork ork?");
    
                }
    
            }
    
            // Vymaže vyrovnávací paměť
            this.buffer.text = "";
    
            // Předá zaměření zpět textovému zobrazení, abyste do něj nemuseli znovu klikat
            this._textView.has_focus = true;
    
        }
    
    });

note: (itstool) path: section/p
en: Here we use some basic JavaScript functions to have the penguins say something random. Penguins like fish, though, so if you mention fish we want the penguin to respond to that. To do that, we use the JavaScript String object's match method on <file>this.buffer.text</file>, which returns the contents of our TextBuffer.
cs: Zde používámě některé základní funkce jazyka JavaScript k tomu, aby náš tučňák promluvil. Když na to přijde, tučňáci mají rádi ryby, takže pokud zmíníte rybu, chceme, aby na to tučňák reagoval. K tomu použijeme metodu objektu <code>String</code>, který má JavaScript zabudovaný, vůči <code>this.buffer.text</code>, což vrací obsah našeho objektu <code>TextBuffer</code>.

note: (itstool) path: section/p
en: Since we want to clear out the TextBuffer after each time you click Send, we set <file>this.buffer.text</file> to contain an empty string afterwards. Then we return focus to our TextView, so that you can keep typing without having to click on it beforehand.
cs: Protože chceme, aby se náš <code>TextBuffer</code> pokaždé, když kliknete na <gui>Send</gui> vymazal, nastavíme po té <code>this.buffer.text</code> na prázdný řetězec. Pak vrátím zaměření textovému zobrazení, takže můžete pokračovat v psaní, aniž byste na něj před tím museli klikat.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new TextViewExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new TextViewExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished TextViewExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci konečné třídy TextViewExample a aplikaci spustíme.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    class TextViewExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstextview'
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Talk to a Penguin",
                default_height: 400,
                default_width: 440,
                border_width: 20 });
    
            // Create a label for the penguin to talk to you
            this._penguin = new Gtk.Label ({
                height_request: 180,
                width_request: 400,
                label: "Squaaaak?",
                wrap: true });
    
            // Create a textview for you to talk to the penguin
            this.buffer = new Gtk.TextBuffer();
            this._textView = new Gtk.TextView ({
                buffer: this.buffer,
                editable: true,
                wrap_mode: Gtk.WrapMode.WORD });
    
            // Create a "scrolled window" to put your textview in so it will scroll
            this._scrolled = new Gtk.ScrolledWindow ({
                hscrollbar_policy: Gtk.PolicyType.AUTOMATIC,
                vscrollbar_policy: Gtk.PolicyType.AUTOMATIC,
                shadow_type: Gtk.ShadowType.ETCHED_IN,
                height_request: 180,
                width_request: 400, });
    
            // Put the textview into the scrolled window
            this._scrolled.add_with_viewport (this._textView);
    
            // Create a grid to organize them in
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Put the label and textview in the grid one on top of the other
            this._grid.attach (this._penguin, 0, 0, 1, 1);
            this._grid.attach (this._scrolled, 0, 1, 1, 1);
    
            // Create a button to send your message to the penguin
            this._send = new Gtk.Button ({
                halign: Gtk.Align.END,
                margin_top: 20,
                label: "Send" });
            this._send.connect ('clicked', this._chat.bind(this));
    
            // Create a grid that will have the other grid on top and the button on bottom
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Add the other grid and the button to the main grid
            this._mainGrid.attach (this._grid, 0, 0, 1, 1);
            this._mainGrid.attach (this._send, 0, 1, 1, 1);
    
            // Attach the main grid to the window
            this._window.add (this._mainGrid);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _chat() {
    
            // Create a random number to determine what the penguin says
            this.number = Math.floor ((Math.random() * 3) + 1);
    
            // Did you actually say anything?
            if (this.buffer.text) {
    
                // Did you mention fish?
                if (this.buffer.text.match (/fish/gi)) {
    
                    // Have the penguin squaak about fish
                    if (this.number == 1)
                        this._penguin.set_label ("FISH!");
    
                    else if (this.number == 2)
                        this._penguin.set_label ("Fish fish fish fish. Fish!");
    
                    else
                        this._penguin.set_label ("Fish? Fish fish fish. Fish fish. FISH!");
    
                }
    
                // I guess you didn't mention fish
                else {
    
                    // Have the penguin talk about penguinny stuff
                    if (this.number == 1)
                        this._penguin.set_label ("SQUAAK!");
    
                    else if (this.number == 2)
                        this._penguin.set_label ("Ork ork ork ork squaak. Squaak squaak! *waves flippers*");
    
                    else
                        this._penguin.set_label ("Ork ork ork ork ork?");
    
                }
    
            }
    
            // Clear the buffer
            this.buffer.text = "";
    
            // Give focus back to the textview so you don't have to click it again
            this._textView.has_focus = true;
        }
    };
    
    // Run the application
    let app = new TextViewExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    class TextViewExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstextview'
            });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow  ({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Talk to a Penguin",
                default_height: 400,
                default_width: 440,
                border_width: 20 });
    
            // Vytvoří popisek přes který k vám bude promlouvat tučňák
            this._penguin = new Gtk.Label ({
                height_request: 180,
                width_request: 400,
                label: "Squaaaak?",
                wrap: true });
    
            // Vytvoří textové zobrazení, přes které můžete mluvit na tučňáka
            this.buffer = new Gtk.TextBuffer();
            this._textView = new Gtk.TextView ({
                buffer: this.buffer,
                editable: true,
                wrap_mode: Gtk.WrapMode.WORD });
    
            // Vytvoří okno s posuvníky pro vložení textového zobrazení, aby
            // mohlo posouvat svůj obsah
            this._scrolled = new Gtk.ScrolledWindow ({
                hscrollbar_policy: Gtk.PolicyType.AUTOMATIC,
                vscrollbar_policy: Gtk.PolicyType.AUTOMATIC,
                shadow_type: Gtk.ShadowType.ETCHED_IN,
                height_request: 180,
                width_request: 400, });
    
            // Vloží textové zobrazení do okna s posuvníky
            this._scrolled.add_with_viewport (this._textView);
    
            // Vytvoří mřížku pro uspořádní widgetů
            this._grid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Vloží popisek a textové zobrazení do mřížky, jeden nad druhý
            this._grid.attach (this._penguin, 0, 0, 1, 1);
            this._grid.attach (this._scrolled, 0, 1, 1, 1);
    
            // Vytvoří tlačítko pro odeslání vaší zprávy tučňákovi
            this._send = new Gtk.Button ({
                halign: Gtk.Align.END,
                margin_top: 20,
                label: "Send" });
            this._send.connect ('clicked', this._chat.bind(this));
    
            // Vytvoří mřížku pro poddružnou mřížku nahoře a tlačítko dole
            this._mainGrid = new Gtk.Grid ({
                halign: Gtk.Align.CENTER,
                valign: Gtk.Align.CENTER });
    
            // Přidá poddružnou mřížku a tlačítko do hlavní mřížky
            this._mainGrid.attach (this._grid, 0, 0, 1, 1);
            this._mainGrid.attach (this._send, 0, 1, 1, 1);
    
            // Připojí hlavní mřížku do okna
            this._window.add (this._mainGrid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _chat() {
    
            // Vytvoří náhodné číslo, které určí, co tučňák řekne
            this.number = Math.floor ((Math.random() * 3) + 1);
    
            // Řekli jste právě něco?
            if (this.buffer.text) {
    
                // Zmínili jste rybu?
                if (this.buffer.text.match (/fish/gi)) {
    
                    // Tučňák musí zaskřehovat o rybě
                    if (this.number == 1)
                        this._penguin.set_label ("FISH!");
    
                    else if (this.number == 2)
                        this._penguin.set_label ("Fish fish fish fish. Fish!");
    
                    else
                        this._penguin.set_label ("Fish? Fish fish fish. Fish fish. FISH!");
    
                }
    
                // Myslím, že jsem se nezmínil o rybě
                else {
    
                    // Tučňák pokecá o všedních záležitostech tučňáků
                    if (this.number == 1)
                        this._penguin.set_label ("SQUAAK!");
    
                    else if (this.number == 2)
                        this._penguin.set_label ("Ork ork ork ork squaak. Squaak squaak! *waves flippers*");
    
                    else
                        this._penguin.set_label ("Ork ork ork ork ork?");
    
                }
    
            }
    
            // Vymaže vyrovnávací paměť
            this.buffer.text = "";
    
            // Předá zaměření zpět textovému zobrazení, abyste do něj nemuseli znovu klikat
            this._textView.has_focus = true;
        }
    };
    
    // Spustí aplikaci
    let app = new TextViewExample ();
    app.application.run (ARGV);

note: (itstool) path: info/desc
en: Widget that displays a GtkTextBuffer
cs: Widget, který zobrazuje GtkTextBuffer

note: (itstool) path: note/p
en: This is an example of Gtk.TextView.
cs: Toto je příklad widgetu Gtk.TextView.

note: (itstool) path: note/p
en: But we can also have a new line if we write a long sentence (the text will wrap breaking lines between words).
cs: Můžeme se ale také dostat na nový řádek, když píšeme dlouhé věty (text bude zalomen na řádky mezi slovy).

note: (itstool) path: note/p
en: If we have a loooooooooooooooooooooooooooooooooooong
cs: Když máme dlouhééééééééééééééééééééééééééééééééééé

note: (itstool) path: note/p
en: (that was long)
cs: (to bylo dlouhé)

note: (itstool) path: note/p
en: word, an horizontal scrollbar will appear.
cs: slovo, objeví se vodorovný posuvník.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="TextView Example", application=app)
            self.set_default_size(300, 450)
    
            # a scrollbar for the child widget (that is going to be the textview)
            scrolled_window = Gtk.ScrolledWindow()
            scrolled_window.set_border_width(5)
            # we scroll only if needed
            scrolled_window.set_policy(
                Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
    
            # a text buffer (stores text)
            buffer1 = Gtk.TextBuffer()
    
            # a textview (displays the buffer)
            textview = Gtk.TextView(buffer=buffer1)
            # wrap the text, if needed, breaking lines in between words
            textview.set_wrap_mode(Gtk.WrapMode.WORD)
    
            # textview is scrolled
            scrolled_window.add(textview)
    
            self.add(scrolled_window)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="TextView Example", application=app)
            self.set_default_size(300, 450)
    
            # Posuvníky pro synovský widget (což bude TextView)
            scrolled_window = Gtk.ScrolledWindow()
            scrolled_window.set_border_width(5)
            # Posuvníky zobrazit jen v případě potřeby
            scrolled_window.set_policy(
                Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
    
            # Textová vyrovnávací paměť (uchovává text)
            buffer1 = Gtk.TextBuffer()
    
            # TextView (zobrazuje obsah vyrovnávací paměti)
            textview = Gtk.TextView(buffer=buffer1)
            # wrap the text, if needed, breaking lines in between words
            textview.set_wrap_mode(Gtk.WrapMode.WORD)
    
            # TextView má posuvníky
            scrolled_window.add(textview)
    
            self.add(scrolled_window)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a TextView widget
cs: Užitečné metody pro widget TextView

note: (itstool) path: section/p
en: A <code>Gtk.TextView</code> displays the text stored in a <code>Gtk.TextBuffer</code>. However, most text manipulation is accomplished with iterators, represented by a <code>Gtk.TextIter</code> - a position between two characters in the text buffer. Iterators are not valid indefinitely; whenever the buffer is modified in a way that affects the contents of the buffer, all outstanding iterators become invalid. Because of this, iterators can’t be used to preserve positions across buffer modifications. To preserve a position, we use a <code>Gtk.TextMark</code>, that can be set visible with <code>visible(True)</code>. A text buffer contains two built-in marks; an "insert" mark (the position of the cursor) and the "selection_bound" mark.
cs: <code>Gtk.TextView</code> zobrazuje text uchovávaný v <code>Gtk.TextBuffer</code>. Většina zásahů do textu je však prováděna pomocí iterátorů představovaných objektem <code>Gtk.TextIter</code> – pozicí mezi dvěma znaky v textové vyrovnávací paměti. Iterátory nemají trvalou platnost. Vždy, když dojde ke změně ve vyrovnávací paměti způsobem, který ovlivní obsah, stanou se všechny zasažené iterátory neplatnými. Z tohoto důvodu nelze iterátory použít k uchování pozic mezi změnami vyrovnávací paměti. K uchování pozice použijeme značky <code>Gtk.TextMark</code>, které lze zviditelnit pomocí <code>visible(True)</code>. Textová vyrovnávací paměť obsahuje dvě vestavěné značky. Značku „insert“ (pozice kurzoru) a „selection_bound“ (hranice výběru).

note: (itstool) path: section/p
en: Methods for a TextView widget:
cs: Metody pro widget TextView:

note: (itstool) path: item/p
en: The TextView widget is by default editable. If you prefer otherwise, use <code>set_editable(False)</code>. If the buffer has no editable text, it might be a good idea to use <code>set_cursor_visible(False)</code> as well.
cs: Widget <code>TextView</code> umožňuje ve výchozím stavu úpravy. Pokud požadujete opak, použijte <code>set_editable(False)</code>. Pokud vyrovnávací paměť nemá upravitelný text, je dobrý nápad také použít <code>set_cursor_visible(False)</code> ke skrytí kurzoru.

note: (itstool) path: item/p
en: The justification of the text is set with <code>set_justification(Gtk.Justification.JUSTIFICATION)</code> where <code>JUSTIFICATION</code> is one of <code>LEFT, RIGHT, CENTER, FILL</code>.
cs: Zarovnání textu se nastavuje pomocí <code>set_justification(Gtk.Justification.JUSTIFICATION)</code>, kde <code>JUSTIFICATION</code> je něco z <code>LEFT, RIGHT, CENTER, FILL</code>.

note: (itstool) path: item/p
en: The line wrapping of the text is set with <code>set_wrap_mode(Gtk.WrapMode.WRAP)</code> where <code>WRAP</code> is one of <code>NONE</code> (the text area is made wider), <code>CHAR</code> (break lines anywhere the cursor can appear), <code>WORD</code> (break lines between words), <code>WORD_CHAR</code> (break lines between words, but if that is not enough between characters).
cs: Zalamování textu se nastavuje pomocí <code>set_wrap_mode(Gtk.WrapMode.WRAP)</code>, kde <code>WRAP</code> je jedno z <code>NONE</code> (textová oblast bude rozšířena), <code>CHAR</code> (řádky se zalamují, kdekoliv se může vyskytnout kurzor), <code>WORD</code> (řádky se zalamují za celými slovy), <code>WORD_CHAR</code> (řádky se zalamují mezi slovy, ale když to není možné, tak i mezi znaky).

note: (itstool) path: section/p
en: Methods for a TextBuffer widget:
cs: Metody pro widget TextBuffer:

note: (itstool) path: item/p
en: <code>get_insert()</code> returns the <code>Gtk.TextMark</code> that represents the cursor, that is the insertion point.
cs: <code>get_insert()</code> vrací <code>Gtk.TextMark</code>, který představuje kurzor, což je místo vkládání.

note: (itstool) path: item/p
en: <code>get_selection_bound()</code> returns the <code>Gtk.TextMark</code> that represents the selection bound.
cs: <code>get_selection_bound()</code> vrací <code>Gtk.TextMark</code>, který představuje hranice výběru.

note: (itstool) path: item/p
en: <code>set_text("some text", length)</code> where <code>length</code> is a positive integer or <code>-1</code>, sets the content of the buffer as the first <code>length</code> characters of the <code>"some text"</code> text. If <code>length</code> is omitted or <code>-1</code>, the text is inserted completely. The content of the buffer, if there is any, is destroyed.
cs: <code>set_text("nějaký text", délka)</code>, kde <code>délka</code> je celé kladné číslo nebo <code>-1</code>, nastaví obsah vyrovnávací paměti prvních <code>délka</code> znaků z textu <code>"nějaký text"</code>. Jestliže je <code>délka</code> vynechána nebo <code>-1</code>, je text vložen celý. Pokud byl ve vyrovnávací paměti před tím nějaký obsah, je zlikvidován.

note: (itstool) path: item/p
en: <code>insert(iter, "some text", length)</code> where <code>iter</code> is a text iterator and <code>length</code> is a positive integer or <code>-1</code>, inserts in the buffer at <code>iter</code> the first <code>length</code> characters of the <code>"some text"</code> text. If <code>length</code> is omitted or <code>-1</code>, the text is inserted completely.
cs: <code>insert(iterátor, "nějaký text", délka)</code>, kde <code>iterárot</code> je textový iterátor a <code>délka</code> je celé kladné číslo nebo <code>-1</code>, vloží do vyrovnávací paměti na pozici danou <code>iterátorem</code> prvních <code>délka</code> znaků z textu <code>"nějaký text"</code>. Jestliže je <code>délka</code> vynechána nebo je <code>-1</code>, je text vložen celý.

note: (itstool) path: item/p
en: <code>insert_at_cursor("some text", length)</code> does the same as <code>insert(iter, "some text", length)</code>, with the current cursor taken as <code>iter</code>.
cs: <code>insert_at_cursor("nějaký text", délka)</code> dělá to stejné, co <code>insert(iterátor, "nějaký text", délka)</code> s tím, že aktuální kurzor se vezme jako <code>iterátor</code>.

note: (itstool) path: item/p
en: <code>create_mark("mark_name", iter, left_gravity)</code> where <code>iter</code> is a <code>Gtk.TextIter</code> and <code>left_gravity</code> is a boolean, creates a <code>Gtk.TextMark</code> at the position of <code>iter</code>. If <code>"mark_name"</code> is <code>None</code>, the mark is anonymous; otherwise, the mark can be retrieved by name using <code>get_mark()</code>. If a mark has left gravity, and text is inserted at the mark’s current location, the mark will be moved to the left of the newly-inserted text. If <code>left_gravity</code> is omitted, it defaults to <code>False</code>.
cs: <code>create_mark("název_značky", iterátor, přitahovat_vlevo)</code>, kde <code>iterátor</code> je <code>Gtk.TextIter</code> a <code>přitahovat_vlevo</code> je pravdivostní hodnota, vytvoří značku <code>Gtk.TextMark</code> na pozici <code>iterátor</code>. Pokud je <code>"název_značky"</code> zadán jako <code>None</code>, je značka anonymní, v opačném případě ji lze získat pomocí <code>get_mark()</code>. Když je přitahována vlevo, a na místo aktuální značky je vkládán text, posouvá se značka nalevo od nově vkládaného textu. V případe, že je <code>přitahovat_vlevo</code> vynecháno, je výchozí hodnotou <code>False</code>.

note: (itstool) path: item/p
en: To specify that some text in the buffer should have specific formatting, you must define a tag to hold that formatting information, and then apply that tag to the region of text using <code>create_tag("tag name", property)</code> and <code>apply_tag(tag, start_iter, end_iter)</code> as in, for instance:
cs: Abyste nějakému textu ve vyrovnávací paměti určili konkrétní formát, musíte nadefinovat značku (<code>tag</code>), která si bude pamatovat formátovací informace, a pak ji použít na úsek textu pomocí <code>create_tag("název značky", vlastnost)</code> a <code>apply_tag(značka, iterátor_počátku, iterátor_konce)</code>. Například:

note: (itstool) path: item/p
en: The following are some of the common styles applied to text:
cs: Následují některé obvyklé styly používané u textu:

note: (itstool) path: item/p
en: Background colour ("background" property)
cs: Barva pozadí (vlastnost „background“)

note: (itstool) path: item/p
en: Foreground colour ("foreground" property)
cs: Barva popředí (vlastnost „foreground“)

note: (itstool) path: item/p
en: Underline ("underline" property)
cs: Podtržení (vlastnost „underline“)

note: (itstool) path: item/p
en: Bold ("weight" property)
cs: Tučné (vlastnost „weight“)

note: (itstool) path: item/p
en: Italics ("style" property)
cs: Kurzíva (vlastnost „style“)

note: (itstool) path: item/p
en: Strikethrough ("strikethrough" property)
cs: Přeškrtnutí (vlastnost „strikethrouhg“)

note: (itstool) path: item/p
en: Justification ("justification" property)
cs: Zarovnání (vlastnost „justification“)

note: (itstool) path: item/p
en: Size ("size" and "size-points" properties)
cs: Velikost (vlastnosti „size“ a „size-points“)

note: (itstool) path: item/p
en: Text wrapping ("wrap-mode" property)
cs: Zalamování textu (vlastnost „wrap-mode“)

note: (itstool) path: item/p
en: You can also delete particular tags later using <code>remove_tag()</code> or delete all tags in a given region by calling <code>remove_all_tags()</code>.
cs: Můžete také dodatečně konkrétní značky smazat pomocí <code>remove_tag()</code> nebo smazat všechny značky v zadané oblasti zavoláním <code>remove_all_tags()</code>.

note: (itstool) path: section/p
en: Methods for a TextIter widget
cs: Metody pro widget TextIter

note: (itstool) path: item/p
en: <code>forward_search(needle, flags, limit)</code> searches forward for <code>needle</code>. The search will not continue past the <code>Gtk.TextIter</code> limit. The <code>flags</code> can be set to one of the following, or any combination of it by concatenating them with the bitwise-OR operator <code>|</code>: <code>0</code> (the match must be exact); <code>Gtk.TextSearchFlags.VISIBLE_ONLY</code> (the match may have invisible text interspersed in needle); <code>Gtk.TextSearchFlags.TEXT_ONLY</code> (the match may have pixbufs or child widgets mixed inside the matched range); <code>Gtk.TextSearchFlags.CASE_INSENSITIVE</code> (the text will be matched regardless of what case it is in). The method returns a tuple containing a <code>Gtk.TextIter</code> pointing to the start and to the first character after the match; if no match is found, <code>None</code> is returned.
cs: <code>forward_search(co_hledat, příznaky, omezení)</code> hledá směrem od začátku ke konci <code>co_hledat</code>. Hledání nepokračuje při při dosažení omezení <code>Gtk.TextIter</code>. Parametr <code>příznaky</code> může být nastaven na něco z následujícího, případně i na kombinaci více možností pospojovaných bitovým operátorem OR <code>|</code>: <code>0</code> (musí se shodovat přesně), <code>Gtk.TextSearchFlags.VISIBLE_ONLY</code> (nalezená shoda může být oproti hledanému proložená neviditelným textem), <code>Gtk.TextSearchFlags.TEXT_ONLY</code> (nalezená shoda může mít uvnitř obrázky nebo jiné synovské widgety), <code>Gtk.TextSearchFlags.CASE_INSENSITIVE</code> (text bude porovnáván bez ohledu na velikost písmen). Metoda vrací dvojici obsahující <code>Gtk.TextIter</code> ukazující na začátek shody a na první znak za shodu. Pokud není nic nalezeno, je vráceno <code>None</code>.

note: (itstool) path: item/p
en: <code>backward_search(needle, flags, limit)</code> does the same as <code>forward_search()</code>, but moving backwards.
cs: <code>backward_search(co_hledat, příznaky, omezení)</code> dělá to stejné jako <code>forward_search()</code>, akorát směrem od konce k začátku.

note: (itstool) path: note/p
en: If we have a loooooooooooooooooooooooooooooooooooong word, a horizontal scrollbar will appear.
cs: Když máme dlouhéééééééééééééééééééééééééééééééééééé slovo, objeví se vodorovný posuvník.

note: (itstool) path: page/code
en: /* This is the application. */
    public class MyApplication : Gtk.Application {
    	/* Override the 'activate' signal of GLib.Application. */
    	protected override void activate () {
    		/* Create the window of this application. */
    		new MyWindow (this).show_all ();
    	}
    }
    
    /* This is the window. */
    class MyWindow: Gtk.ApplicationWindow {
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "TextView Example");
    		this.set_default_size (220, 200);
    
    		var buffer = new Gtk.TextBuffer (null); //stores text to be displayed
    		var textview = new Gtk.TextView.with_buffer (buffer); //displays TextBuffer
    		textview.set_wrap_mode (Gtk.WrapMode.WORD); //sets line wrapping
    
    		var scrolled_window = new Gtk.ScrolledWindow (null, null);
    		scrolled_window.set_policy (Gtk.PolicyType.AUTOMATIC,
    		                            Gtk.PolicyType.AUTOMATIC);
    
    		scrolled_window.add (textview);
    		scrolled_window.set_border_width (5);
    
    		this.add (scrolled_window);
    	}
    }
    /* main creates and runs the application. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Toto je aplikace. */
    public class MyApplication : Gtk.Application {
    	/* Přepíše signál "activate" z GLib.Application. */
    	protected override void activate () {
    		/* Vytvoří okno této aplikace. */
    		new MyWindow (this).show_all ();
    	}
    }
    
    /* Toto je okno. */
    class MyWindow: Gtk.ApplicationWindow {
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "TextView Example");
    		this.set_default_size (220, 200);
    
    		var buffer = new Gtk.TextBuffer (null); // uchovává text pro zobrazení
    		var textview = new Gtk.TextView.with_buffer (buffer); // zobrazí TextBuffer
    		textview.set_wrap_mode (Gtk.WrapMode.WORD); // nastaví zalamování řádků
    
    		var scrolled_window = new Gtk.ScrolledWindow (null, null);
    		scrolled_window.set_policy (Gtk.PolicyType.AUTOMATIC,
    		                            Gtk.PolicyType.AUTOMATIC);
    
    		scrolled_window.add (textview);
    		scrolled_window.set_border_width (5);
    
    		this.add (scrolled_window);
    	}
    }
    /* main vytvoří a spustí aplikaci. */
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: A button which retains state
cs: Tlačítko, které si ponechává svůj stav

note: (itstool) path: page/p
en: When this ToggleButton is in an active state, the spinner spins.
cs: Když je ToggleButton aktivován, káča se otáčí.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /*This is the callback function. It is a handler function 
    which reacts to the signal. In this case, it will cause the 
    spinner to start and stop according to how many times the user 
    presses the button.*/
    static void
    button_toggled_cb (GtkWidget *button,
                       gpointer   user_data)
    {
      GtkWidget *spinner = user_data;
    
      if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(button)))
              gtk_spinner_start (GTK_SPINNER (spinner));
      else {
              gtk_spinner_stop (GTK_SPINNER (spinner));
      }
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *button;
      GtkWidget *grid;
      GtkWidget *spinner;
    
      /*Create a window with a title, border width and a default size*/
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "ToggleButton Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
      gtk_container_set_border_width(GTK_CONTAINER(window), 30);
    
      /*Create a togglebutton with a label*/
      button = gtk_toggle_button_new_with_label ("Start/Stop");
    
      /*Create a spinner, with extra horizontal and vertical space*/
      spinner = gtk_spinner_new ();
      gtk_widget_set_hexpand (spinner, TRUE);
      gtk_widget_set_vexpand (spinner, TRUE);
    
      /*Create a grid and set the row spacing, attach the togglebutton 
      and spinner onto the grid and position them accordingly*/
      grid = gtk_grid_new();
      gtk_grid_set_row_homogeneous (GTK_GRID (grid), FALSE);
      gtk_grid_set_row_spacing (GTK_GRID (grid), 15);
      gtk_grid_attach (GTK_GRID (grid), spinner, 0, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), button, 0, 1, 1, 1);
      
      gtk_container_add (GTK_CONTAINER (window), grid);
    
      /*Connecting the toggled signal to the callback*/
      g_signal_connect (GTK_TOGGLE_BUTTON (button), "toggled", 
                        G_CALLBACK (button_toggled_cb), spinner);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    
    
    /* Toto je funkce zpětného volání. Jedná se o zpracující funkci, 
       která reaguje na signál. V tomto případě způsobí, že káča 
       se začne otáčet a zastaví se, podle toho, kolikrát uživatel
       tlačítko zmáčkl. */
    static void
    button_toggled_cb (GtkWidget *button,
                       gpointer   user_data)
    {
      GtkWidget *spinner = user_data;
    
      if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(button)))
              gtk_spinner_start (GTK_SPINNER (spinner));
      else {
              gtk_spinner_stop (GTK_SPINNER (spinner));
      }
    }
    
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *window;
      GtkWidget *button;
      GtkWidget *grid;
      GtkWidget *spinner;
    
      /* Vytvoří okno s názvem, šířkou okraje a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "ToggleButton Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
      gtk_container_set_border_width(GTK_CONTAINER(window), 30);
    
      /* Vytvoří ToggleButton s popiskem */
      button = gtk_toggle_button_new_with_label ("Start/Stop");
    
      /* Vytvoří Spinner s dodatečným místem vodorovně i svisle */
      spinner = gtk_spinner_new ();
      gtk_widget_set_hexpand (spinner, TRUE);
      gtk_widget_set_vexpand (spinner, TRUE);
    
      /* Vytvoří mřížku a nastaví rozestupy řádků, připojí do ní 
         ToggleButton a Spinner a patřičně je umístí */
      grid = gtk_grid_new();
      gtk_grid_set_row_homogeneous (GTK_GRID (grid), FALSE);
      gtk_grid_set_row_spacing (GTK_GRID (grid), 15);
      gtk_grid_attach (GTK_GRID (grid), spinner, 0, 0, 1, 1);
      gtk_grid_attach (GTK_GRID (grid), button, 0, 1, 1, 1);
      
      gtk_container_add (GTK_CONTAINER (window), grid);
    
      /* Napojí signál "toggled" k funkci zpětného volání */
      g_signal_connect (GTK_TOGGLE_BUTTON (button), "toggled", 
                        G_CALLBACK (button_toggled_cb), spinner);
    
      gtk_widget_show_all (window);
    }
    
    
    
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: info/desc
en: Stays pressed until you click it again
cs: Zůstane zmáčknuté, dokud na něj znovu nekliknete

note: (itstool) path: page/p
en: A ToggleButton is like a normal <link xref="button.js">Button</link>, except that it stays pressed in when you click it. You can use it like an on/off switch, to control things like the <link xref="spinner.js">Spinner</link> in this example.
cs: <code>ToggleButton</code> (přepínací tlačítko) je podobné jako normální tlačítko (<link xref="button.js">Button</link>), jen s tím rozdílem, že po kliknutí zůstane zmáčknuté. Můžete jej používat ve funkci zapnuto/vypnuto pro řízení věcí, jako třeba káči (<link xref="spinner.js">Spinner</link>) v tomto příkladu.

note: (itstool) path: page/p
en: A ToggleButton's get_active method returns true if it's pressed in, and false if it's not. Its set_active method is used if you want to change its state without needing to click on it. When it changes state from pressed in to popped out and vice-versa, it sends out the "toggled" signal, which you can connect to a function to do something.
cs: Metoda <code>get_active</code> přepínacího tlačítka vrací <code>true</code>, když je zmáčknuté, a <code>false</code>, když není. Metoda <code>set_active</code> se používá, když chcete změnit jeho stav programově, bez klikání. Když se jeho stav změní ze zmáčknutého na nezmáčknuté nebo naopak, vyšle signál <code>"toggled"</code>, který můžete napojit na funkci, která něco udělá.

note: (itstool) path: section/code
en: 
    const ToggleButtonExample = new Lang.Class({
        Name: 'ToggleButton Example',
    
        // Create the application itself
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstogglebutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Connect 'activate' and 'startup' signals to the callback functions
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Callback function for 'activate' signal presents window when active
        _onActivate: function() {
            this._window.present();
        },
    
        // Callback function for 'startup' signal builds the UI
        _onStartup: function() {
            this._buildUI ();
        },
cs: 
    const ToggleButtonExample = new Lang.Class({
        Name: 'ToggleButton Example',
    
        // Vytvoří vlastní aplikaci
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstogglebutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate: function() {
            this._window.present();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function() {
            this._buildUI ();
        },

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI: function() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 300,
                default_width: 300,
                border_width: 30,
                title: "ToggleButton Example"});
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 300,
                default_width: 300,
                border_width: 30,
                title: "ToggleButton Example"});

note: (itstool) path: section/title
en: Creating the ToggleButton and other widgets
cs: Vytvoření ToggleButton a dalších widgetů

note: (itstool) path: section/code
en: 
            // Create the spinner that the button stops and starts
            this._spinner = new Gtk.Spinner ({hexpand: true, vexpand: true});
cs: 
            // Vytvoří káču, kterou přepínací tlačítko zastavuje a spouští
            this._spinner = new Gtk.Spinner ({hexpand: true, vexpand: true});

note: (itstool) path: section/p
en: We want this <link xref="spinner.js">Spinner</link> to expand vertically and horizontally, to take up as much space as possible inside the window.
cs: Chceme, aby se tento widget <link xref="spinner.js">Spinner</link> roztáhl svisle i vodorovně a zabral co nejvíce místa uvnitř okna.

note: (itstool) path: section/code
en: 
            // Create the togglebutton that starts and stops the spinner
            this._toggleButton = new Gtk.ToggleButton ({label: "Start/Stop"});
            this._toggleButton.connect ('toggled', Lang.bind (this, this._onToggle));
cs: 
            // Vytvoří ToggleButton, které spouští a zastavuje káču
            this._toggleButton = new Gtk.ToggleButton ({label: "Start/Stop"});
            this._toggleButton.connect ('toggled', Lang.bind (this, this._onToggle));

note: (itstool) path: section/p
en: Creating a ToggleButton is a lot like creating a normal <link xref="button.js">Button</link>. The biggest difference is that you're handling a "toggled" signal instead of a "clicked" signal. This code binds the _onToggle function to that signal, so that it's called whenever our ToggleButton is toggled.
cs: Vytváření <code>ToggleButton</code> není tak úplně stejné, jako vytváření widgetu <link xref="button.js">Button</link>. Největší rozdíl je v tom, že obsluhujete signál <code>"toggled"</code> místo <code>"clicked"</code>. Tento kód napojí funkci <code>_onToggle</code> na tento signál, takže bude zavolána pokaždé, když se přepínací tlačítko přepne.

note: (itstool) path: section/code
en: 
            // Create a grid and put everything in it
            this._grid = new Gtk.Grid ({
                row_homogeneous: false,
                row_spacing: 15});
            this._grid.attach (this._spinner, 0, 0, 1, 1);
            this._grid.attach (this._toggleButton, 0, 1, 1, 1);
cs: 
            // Vytvoří mřížku a vše do ní vloží
            this._grid = new Gtk.Grid ({
                row_homogeneous: false,
                row_spacing: 15});
            this._grid.attach (this._spinner, 0, 0, 1, 1);
            this._grid.attach (this._toggleButton, 0, 1, 1, 1);

note: (itstool) path: section/p
en: Here we create a simple <link xref="grid.js">Grid</link> to organize everything in, then attach the Spinner and ToggleButton to it.
cs: Zde vytvoříme jednoduchý widget <link xref="grid.js">Grid</link> pomocí kterého vše uspořádáme. Následně do něj připojíme káču a přepínací tlačítko.

note: (itstool) path: section/code
en: 
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
        },
cs: 
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        },

note: (itstool) path: section/p
en: Now we add the Grid to the Window, and tell the Window to show itself and its child widgets when the application is started.
cs: Nyní přidáme mřížku do okna a řekneme oknu, aby zobrazilo sebe a své synovské widgety, až se spustí aplikace.

note: (itstool) path: section/title
en: Making something happen when the ToggleButton is toggled
cs: Zajištění, že se něco stane, když je ToggleButton přepnut

note: (itstool) path: section/code
en: 
        _onToggle: function() {
    
            // Start or stop the spinner
            if (this._toggleButton.get_active ())
                this._spinner.start ();
            else this._spinner.stop ();
    
        }
    
    });
cs: 
        _onToggle: function() {
    
            // Spustí nebo zastaví káču
            if (this._toggleButton.get_active ())
                this._spinner.start ();
            else this._spinner.stop ();
    
        }
    
    });

note: (itstool) path: section/p
en: Whenever someone toggles the button, this function checks what its state is afterwards using get_active and starts or stops the spinner accordingly. We want it to spin only while the button is pressed in, so if get_active returns true we start the spinner. Otherwise, we tell it to stop.
cs: Kdykoliv někdo přepínací tlačítko přepne, tato funkce zkontroluje jeho stav a pak použije <code>get_active</code> a příslušně spustí nebo zastaví káču. Chceme, aby se otáčela, jen když je tlačítko zmáčknuté, tj. <code>get_active</code> vrátí <code>true</code>. V opačném případě ji řekneme, aby se zastavila.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new ToggleButtonExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new ToggleButtonExample ();
    app.application.run (ARGV);

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class ToggleButtonExample {
    
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstogglebutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 300,
                default_width: 300,
                border_width: 30,
                title: "ToggleButton Example"});
    
            // Create the spinner that the button stops and starts
            this._spinner = new Gtk.Spinner ({hexpand: true, vexpand: true});
    
            // Create the togglebutton that starts and stops the spinner
            this._toggleButton = new Gtk.ToggleButton ({label: "Start/Stop"});
            this._toggleButton.connect ('toggled', this._onToggle.bind(this));
    
            // Create a grid and put everything in it
            this._grid = new Gtk.Grid ({
                row_homogeneous: false,
                row_spacing: 15});
            this._grid.attach (this._spinner, 0, 0, 1, 1);
            this._grid.attach (this._toggleButton, 0, 1, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _onToggle() {
    
            // Start or stop the spinner
            if (this._toggleButton.get_active ())
                this._spinner.start ();
            else this._spinner.stop ();
    
        }
    };
    
    // Run the application
    let app = new ToggleButtonExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk;
    
    class ToggleButtonExample {
    
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstogglebutton',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 300,
                default_width: 300,
                border_width: 30,
                title: "ToggleButton Example"});
    
            // Vytvoří káču, kterou přepínací tlačítko zastavuje a spouští
            this._spinner = new Gtk.Spinner ({hexpand: true, vexpand: true});
    
            // Vytvoří ToggleButton, které spouští a zastavuje káču
            this._toggleButton = new Gtk.ToggleButton ({label: "Start/Stop"});
            this._toggleButton.connect ('toggled', this._onToggle.bind(this));
    
            // Vytvoří mřížku a vše do ní vloží
            this._grid = new Gtk.Grid ({
                row_homogeneous: false,
                row_spacing: 15});
            this._grid.attach (this._spinner, 0, 0, 1, 1);
            this._grid.attach (this._toggleButton, 0, 1, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _onToggle() {
    
            // Spustí nebo zastaví káču
            if (this._toggleButton.get_active ())
                this._spinner.start ();
            else this._spinner.stop ();
    
        }
    };
    
    // Spustí aplikaci
    let app = new ToggleButtonExample ();
    app.application.run (ARGV);

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # a window
    
        def __init__(self, app):
            Gtk.Window.__init__(
                self, title="ToggleButton Example", application=app)
            self.set_default_size(300, 300)
            self.set_border_width(30)
    
            # a spinner animation
            self.spinner = Gtk.Spinner()
            # with extra horizontal space
            self.spinner.set_hexpand(True)
            # with extra vertical space
            self.spinner.set_vexpand(True)
    
            # a togglebutton
            button = Gtk.ToggleButton.new_with_label("Start/Stop")
            # connect the signal "toggled" emitted by the togglebutton
            # when its state is changed to the callback function toggled_cb
            button.connect("toggled", self.toggled_cb)
    
            # a grid to allocate the widgets
            grid = Gtk.Grid()
            grid.set_row_homogeneous(False)
            grid.set_row_spacing(15)
            grid.attach(self.spinner, 0, 0, 1, 1)
            grid.attach(button, 0, 1, 1, 1)
    
            # add the grid to the window
            self.add(grid)
    
        # callback function for the signal "toggled"
        def toggled_cb(self, button):
            # if the togglebutton is active, start the spinner
            if button.get_active():
                self.spinner.start()
            # else, stop it
            else:
                self.spinner.stop()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
        # a window
    
        def __init__(self, app):
            Gtk.Window.__init__(
                self, title="ToggleButton Example", application=app)
            self.set_default_size(300, 300)
            self.set_border_width(30)
    
            # Animovaná káča
            self.spinner = Gtk.Spinner()
            # S dodatečným vodorovným místem
            self.spinner.set_hexpand(True)
            # S dodatečným svislým místem
            self.spinner.set_vexpand(True)
    
            # Přepínací tlačítko
            button = Gtk.ToggleButton.new_with_label("Start/Stop")
            # Napojí signál "toggled" vyslaný přepínacím tlačítkem, když
            # se změní jeho stav, na funkci zpětného volání toggled_cb
            button.connect("toggled", self.toggled_cb)
    
            # Mřížka pro umístění widgetů
            grid = Gtk.Grid()
            grid.set_row_homogeneous(False)
            grid.set_row_spacing(15)
            grid.attach(self.spinner, 0, 0, 1, 1)
            grid.attach(button, 0, 1, 1, 1)
    
            # Přidá mřížku do okna
            self.add(grid)
    
        # Funkce zpětného volání pro signál "toggled"
        def toggled_cb(self, button):
            # Když je přepínací tlačtíko aktivní, spustí se káča
            if button.get_active():
                self.spinner.start()
            # Jina se zastaví
            else:
                self.spinner.stop()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a ToggleButton widget
cs: Užitečné metody pro widget ToggleButton

note: (itstool) path: section/p
en: In line 22 the signal <code>"toggled"</code> is connected to the callback function <code>toggled_cb()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 22 je signál <code>"toggled"</code> napojen na funkci zpětného volání <code>toggled_cb()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: page/code
en: public class MyWindow : Gtk.ApplicationWindow {
    
    	Gtk.Spinner spinner;
    
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "ToggleButton Example");
    
    		this.set_default_size (300, 300);
    		this.border_width = 30;
    
    		/*Spinner*/
    		spinner = new Gtk.Spinner ();
    		spinner.set_hexpand (true);
    		spinner.set_vexpand (true);
    
    		/*ToggleButton*/
    		var togglebutton = new Gtk.ToggleButton.with_label ("Start/Stop");
    		togglebutton.toggled.connect (toggled_cb);
    
    		/*Grid*/
    		var grid = new Gtk.Grid ();
    		grid.set_row_homogeneous (false);
    		grid.set_row_spacing (15);
    		grid.attach (spinner, 0, 0, 1, 1);
    		grid.attach (togglebutton, 0, 1, 1, 1);
    
    		this.add (grid);
    	}
    
    	void toggled_cb (Gtk.ToggleButton button) {
    		if (button.get_active()) {
    			spinner.start ();
    		}
    		else {
    			spinner.stop ();
    		}
    	}
    }
    
    public class MyApplication : Gtk.Application {
    
    	protected override void activate () {
    
    		//Show all the things
    		new MyWindow (this).show_all ();
    	}
    
    	internal MyApplication () {
    		Object (application_id: "org.example.spinner");
    	}
    }
    
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: public class MyWindow : Gtk.ApplicationWindow {
    
    	Gtk.Spinner spinner;
    
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "ToggleButton Example");
    
    		this.set_default_size (300, 300);
    		this.border_width = 30;
    
    		/* Spinner */
    		spinner = new Gtk.Spinner ();
    		spinner.set_hexpand (true);
    		spinner.set_vexpand (true);
    
    		/* ToggleButton */
    		var togglebutton = new Gtk.ToggleButton.with_label ("Start/Stop");
    		togglebutton.toggled.connect (toggled_cb);
    
    		/* Grid */
    		var grid = new Gtk.Grid ();
    		grid.set_row_homogeneous (false);
    		grid.set_row_spacing (15);
    		grid.attach (spinner, 0, 0, 1, 1);
    		grid.attach (togglebutton, 0, 1, 1, 1);
    
    		this.add (grid);
    	}
    
    	void toggled_cb (Gtk.ToggleButton button) {
    		if (button.get_active()) {
    			spinner.start ();
    		}
    		else {
    			spinner.stop ();
    		}
    	}
    }
    
    public class MyApplication : Gtk.Application {
    
    	protected override void activate () {
    
    		//Show all the things
    		new MyWindow (this).show_all ();
    	}
    
    	internal MyApplication () {
    		Object (application_id: "org.example.spinner");
    	}
    }
    
    public int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: A bar of buttons
cs: Lišta s tlačítky

note: (itstool) path: page/p
en: Toolbar can contain either text or stock icons. In this sample we use stock icons. This example has fullscreen functionality.
cs: Nástrojová lišta může obsahovat text nebo standardní ikony. V tomto příkladu používáme standardní ikony. Tento příklad obsahuje funkci pro zobrazení na celou obrazovku.

note: (itstool) path: page/p
en: This example uses SimpleActions (window and app). App actions can easily be added to the app menu.
cs: Tento příklad používá <code>SimpleAction</code> (jednoduchá akce), pro okno i pro aplikaci. Akci pro aplikaci lze snadno přidat do aplikační nabídky.

note: (itstool) path: page/code
en: 
    #include &lt;gtk/gtk.h&gt;
    
    /* Declare these two Toolbuttons, as they will be used in both the fullscreen
     * action callback as well as the activate function.
     */
    GtkToolItem *fullscreen_button;
    GtkToolItem *leavefullscreen_button;
    
    
    
    /* Callback function for the undo action */
    static void
    undo_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      g_print ("You clicked \"Undo\".\n");
    }
    
    
    
    /* Callback function for the fullscreen action */
    static void
    fullscreen_callback (GSimpleAction *simple,
                         GVariant      *parameter,
                         gpointer       user_data)
    {
      GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (user_data));
    
      GdkWindowState current_state = gdk_window_get_state (window);
    
      /* If the window is currently in fullscreen mode */
      if ( (current_state &amp; GDK_WINDOW_STATE_FULLSCREEN) != 0)
        {
          /* Minimize the window and change to the fullscreen button */
          gdk_window_unfullscreen (window);
          gtk_widget_hide (GTK_WIDGET(leavefullscreen_button));
          gtk_widget_show (GTK_WIDGET(fullscreen_button));
        }
      else
        {
          /* Maximize the window, and change to the unfullscreen button */
          gdk_window_fullscreen (window);
          gtk_widget_hide (GTK_WIDGET (fullscreen_button));
          gtk_widget_show (GTK_WIDGET (leavefullscreen_button));
        }
    }
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      /* Initialize variables */
      GtkWidget *window;
      GtkWidget *grid;
      GtkWidget *toolbar;
    
      GtkToolItem *new_button;
      GtkToolItem *open_button;
      GtkToolItem *undo_button;
    
      GtkStyleContext *style_context;
    
      GSimpleAction *undo_action;
      GSimpleAction *fullscreen_action;
      GSimpleAction *leavefullscreen_action;
    
      /* Create a window with a title and a default size */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Toolbar Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 400, 200);
    
      /* Here we begin to create the toolbar */
      toolbar = gtk_toolbar_new ();
      /* Set the toolbar to be the primary toolbar of the application */
      style_context = gtk_widget_get_style_context (toolbar);
      gtk_style_context_add_class (style_context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
    
      /* Create a button for the "new" action, with a stock image */
      new_button = gtk_tool_button_new_from_stock (GTK_STOCK_NEW);
      /* Show the "new" button's label */
      gtk_tool_item_set_is_important (new_button, TRUE);
      /* Insert the button in the desired position within the toolbar */
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), new_button, 0);
      /* Show the button */
      gtk_widget_show (GTK_WIDGET (new_button));
      /* Set the action name for the "new" action. We use "app.new" to
       * indicate that the action controls the application.
       */
      gtk_actionable_set_action_name (GTK_ACTIONABLE (new_button), "app.new");
    
      /* Repeat the same steps for the "open" action */
      open_button = gtk_tool_button_new_from_stock (GTK_STOCK_OPEN);
      gtk_tool_item_set_is_important (open_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), open_button, 1);
      gtk_widget_show (GTK_WIDGET (open_button));
      gtk_actionable_set_action_name (GTK_ACTIONABLE (open_button), "app.open");
    
      /* Repeat the same steps for the "undo" action */
      undo_button = gtk_tool_button_new_from_stock (GTK_STOCK_UNDO);
      gtk_tool_item_set_is_important (undo_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), undo_button, 2);
      gtk_widget_show (GTK_WIDGET (undo_button));
      /* In this case, we use "win.undo" to indicate that
       * the action controls only the window
       */
      gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "win.undo");
    
      /* Repeat the same steps for the "fullscreen" action */
      fullscreen_button = gtk_tool_button_new_from_stock (GTK_STOCK_FULLSCREEN);
      gtk_tool_item_set_is_important (fullscreen_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), fullscreen_button, 3);
      gtk_widget_show (GTK_WIDGET (fullscreen_button));
      gtk_actionable_set_action_name (GTK_ACTIONABLE (fullscreen_button),
                                      "win.fullscreen");
    
      /*Repeat the same steps for the "leavefullscreen" action */
      leavefullscreen_button = gtk_tool_button_new_from_stock (GTK_STOCK_LEAVE_FULLSCREEN);
      gtk_tool_item_set_is_important (leavefullscreen_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), leavefullscreen_button, 3);
      /* The only difference here is that we don't show the leavefullscreen button,
       * as it will later replace the fullscreen button.
       */
      gtk_actionable_set_action_name (GTK_ACTIONABLE (leavefullscreen_button),
                                      "win.leavefullscreen");
    
      /* Once we've created the bare-bones of the toolbar, we make
       * sure it has enough horizontal space.
       */
      gtk_widget_set_hexpand (toolbar, TRUE);
      gtk_widget_show (toolbar);
    
      /* Attach the toolbar to the grid and add it to the overall window */
      grid = gtk_grid_new ();
      gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 1, 1);
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
      gtk_widget_show (GTK_WIDGET (grid));
    
      /* Use the action names to create the actions that control the window, and
       * connect them to the appropriate callbackfunctions.
       */
      undo_action = g_simple_action_new ("undo", NULL);
      g_signal_connect (undo_action, "activate", G_CALLBACK (undo_callback),
                        GTK_WINDOW (window));
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (undo_action));
    
      fullscreen_action = g_simple_action_new ("fullscreen", NULL);
      g_signal_connect (fullscreen_action, "activate", G_CALLBACK (fullscreen_callback),
                        GTK_WINDOW (window));
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (fullscreen_action));
    
      leavefullscreen_action = g_simple_action_new ("leavefullscreen", NULL);
      g_signal_connect (leavefullscreen_action, "activate", G_CALLBACK (fullscreen_callback),
                        GTK_WINDOW (window));
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (leavefullscreen_action));
    
      gtk_widget_show (window);
    }
    
    
    
    /* Callback function for the new action */
    static void
    new_callback (GSimpleAction *simple,
                  GVariant      *parameter,
                  gpointer       user_data)
    {
      g_print ("You clicked \"New\".\n");
    }
    
    
    
    /* Callback function for the open action */
    static void
    open_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      g_print ("You clicked \"Open\".\n");
    }
    
    
    
    /* In this function, we create the actions in which control the window, and
     * connect their signals to the appropriate callback function.
     */
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      GSimpleAction *new_action;
      GSimpleAction *open_action;
    
      new_action = g_simple_action_new ("new", NULL);
      g_signal_connect (new_action, "activate", G_CALLBACK (new_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (new_action));
    
      open_action = g_simple_action_new ("open", NULL);
      g_signal_connect (open_action, "activate", G_CALLBACK (open_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (open_action));
    }
    
    
    
    /* Startup function for the application */
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: 
    #include &lt;gtk/gtk.h&gt;
    
    /* Deklaruje tato dvě nástrojová tlačítka, protože obě budou použita jak
     * ve zpětném volání akce „celá obrazovka“, tak v aktivační funkci
     */
    GtkToolItem *fullscreen_button;
    GtkToolItem *leavefullscreen_button;
    
    
    
    /* Funkce zpětného volání pro akci „zpět“ */
    static void
    undo_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      g_print ("You clicked \"Undo\".\n");
    }
    
    
    
    /* Funkce zpětného volání pro akci „celá obrazovka“ */
    static void
    fullscreen_callback (GSimpleAction *simple,
                         GVariant      *parameter,
                         gpointer       user_data)
    {
      GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (user_data));
    
      GdkWindowState current_state = gdk_window_get_state (window);
    
      /* Jestliže je okno právě v režimu celé obrazovky */
      if ( (current_state &amp; GDK_WINDOW_STATE_FULLSCREEN) != 0)
        {
          /* Minimalizuje okno a změní tlačítko na „celá obrazovka“ */
          gdk_window_unfullscreen (window);
          gtk_widget_hide (GTK_WIDGET(leavefullscreen_button));
          gtk_widget_show (GTK_WIDGET(fullscreen_button));
        }
      else
        {
          /* Maximalizuje okno a znění tlačítko na „opustit celou obrazovku“ */
          gdk_window_fullscreen (window);
          gtk_widget_hide (GTK_WIDGET (fullscreen_button));
          gtk_widget_show (GTK_WIDGET (leavefullscreen_button));
        }
    }
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      /* Inicializace proměnných */
      GtkWidget *window;
      GtkWidget *grid;
      GtkWidget *toolbar;
    
      GtkToolItem *new_button;
      GtkToolItem *open_button;
      GtkToolItem *undo_button;
    
      GtkStyleContext *style_context;
    
      GSimpleAction *undo_action;
      GSimpleAction *fullscreen_action;
      GSimpleAction *leavefullscreen_action;
    
      /* Vytvoří okno s název pro záhlaví a výchozí velikostí */
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Toolbar Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 400, 200);
    
      /* Zde začínáme vytvářet nástrojovou lištu */
      toolbar = gtk_toolbar_new ();
      /* Nastavíme nástrojovou lištu jako hlavní pro aplikaci */
      style_context = gtk_widget_get_style_context (toolbar);
      gtk_style_context_add_class (style_context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
    
      /* Vytvoříme tlačítko pro akci "new", se standardním obrázkem */
      new_button = gtk_tool_button_new_from_stock (GTK_STOCK_NEW);
      /* Zapne zobrazování popisku tlačítka "new" */
      gtk_tool_item_set_is_important (new_button, TRUE);
      /* Vloží tlačítko na požadovanou pozici na nástrojové liště */
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), new_button, 0);
      /* Zobrazí tlačítko */
      gtk_widget_show (GTK_WIDGET (new_button));
      /* Nastaví název akce pro akci "new". Použijeme "app.new",
       * aby bylo poznak, že akce ovládá aplikaci
       */
      gtk_actionable_set_action_name (GTK_ACTIONABLE (new_button), "app.new");
    
      /* Zopakuje stejné kroky pro akci "open" */
      open_button = gtk_tool_button_new_from_stock (GTK_STOCK_OPEN);
      gtk_tool_item_set_is_important (open_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), open_button, 1);
      gtk_widget_show (GTK_WIDGET (open_button));
      gtk_actionable_set_action_name (GTK_ACTIONABLE (open_button), "app.open");
    
      /* Zopakuje stejné kroky pro akci "undo" */
      undo_button = gtk_tool_button_new_from_stock (GTK_STOCK_UNDO);
      gtk_tool_item_set_is_important (undo_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), undo_button, 2);
      gtk_widget_show (GTK_WIDGET (undo_button));
      /* V tomto případě použijeme "win.undo", aby se poznalo, že
       * akce ovládá jen okno
       */
      gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "win.undo");
    
      /* Zopakuje stejné kroky pro akci "fullscreen" */
      fullscreen_button = gtk_tool_button_new_from_stock (GTK_STOCK_FULLSCREEN);
      gtk_tool_item_set_is_important (fullscreen_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), fullscreen_button, 3);
      gtk_widget_show (GTK_WIDGET (fullscreen_button));
      gtk_actionable_set_action_name (GTK_ACTIONABLE (fullscreen_button),
                                      "win.fullscreen");
    
      /* Zopakuje stejné kroky pro akci "leavefullscreen" */
      leavefullscreen_button = gtk_tool_button_new_from_stock (GTK_STOCK_LEAVE_FULLSCREEN);
      gtk_tool_item_set_is_important (leavefullscreen_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), leavefullscreen_button, 3);
      /* Jediný rozdíl zde je, že se tlačítko "leavefullscreen" nezobrazí,
       * protože až později nahradí tlačítko "fullscreen".
       */
      gtk_actionable_set_action_name (GTK_ACTIONABLE (leavefullscreen_button),
                                      "win.leavefullscreen");
    
      /* Jakmile vytvoříme základ nástrojové lišty, ujistíme se,
       * že je ve vodorovném směru dostatek místa
       */
      gtk_widget_set_hexpand (toolbar, TRUE);
      gtk_widget_show (toolbar);
    
      /* Připojíme nástrojovou lištu do mřížky a tu přidáme do hlavního okna */
      grid = gtk_grid_new ();
      gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 1, 1);
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
      gtk_widget_show (GTK_WIDGET (grid));
    
      /* Použijeme názvy akcí k vytvoření akcí, které ovládají okno, a
       * napojíme je na příslušné funkce zpětného volání
       */
      undo_action = g_simple_action_new ("undo", NULL);
      g_signal_connect (undo_action, "activate", G_CALLBACK (undo_callback),
                        GTK_WINDOW (window));
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (undo_action));
    
      fullscreen_action = g_simple_action_new ("fullscreen", NULL);
      g_signal_connect (fullscreen_action, "activate", G_CALLBACK (fullscreen_callback),
                        GTK_WINDOW (window));
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (fullscreen_action));
    
      leavefullscreen_action = g_simple_action_new ("leavefullscreen", NULL);
      g_signal_connect (leavefullscreen_action, "activate", G_CALLBACK (fullscreen_callback),
                        GTK_WINDOW (window));
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (leavefullscreen_action));
    
      gtk_widget_show (window);
    }
    
    
    
    /* Funkce zpětného volání pro akci "new" */
    static void
    new_callback (GSimpleAction *simple,
                  GVariant      *parameter,
                  gpointer       user_data)
    {
      g_print ("You clicked \"New\".\n");
    }
    
    
    
    /* Funkce zpětného volání pro akci "open" */
    static void
    open_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      g_print ("You clicked \"Open\".\n");
    }
    
    
    
    /* V této funkci vytvoříme akce, které ovládají aplikaci a napojíme
     * jejich signály na příslušnou funkci zpětného volání
     */
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      GSimpleAction *new_action;
      GSimpleAction *open_action;
    
      new_action = g_simple_action_new ("new", NULL);
      g_signal_connect (new_action, "activate", G_CALLBACK (new_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (new_action));
    
      open_action = g_simple_action_new ("open", NULL);
      g_signal_connect (open_action, "activate", G_CALLBACK (open_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (open_action));
    }
    
    
    
    /* Spouštěcí funkce pro aplikaci */
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: info/desc
en: A bar of tools
cs: Nástrojová lišta

note: (itstool) path: page/p
en: This example uses SimpleActions (window and app). App actions can easily be added the the app menu.
cs: Tento příklad používá <code>SimpleAction</code> (pro okno i aplikaci). Akce aplikace lze snadno přidat do aplikační nabídky.

note: (itstool) path: page/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gdk = '3.0';
    imports.gi.versions.Gtk = '3.0';
    
    const Gdk = imports.gi.Gdk;
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class Application {
    
        //create the application
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.myapp',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
           //connect to 'activate' and 'startup' signals to the callback functions
           this.application.connect('activate', this._onActivate.bind(this));
           this.application.connect('startup', this._onStartup.bind(this));
        }
    
        //create the UI (in this case it's just the ApplicationWindow
        _buildUI() {
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Toolbar Example",
                default_height: 200,
                default_width: 400
            });
    
            this._grid = new Gtk.Grid();
            this._window.add(this._grid);
            this._grid.show();
    
            this._createToolbar();
            this._toolbar.set_hexpand(true);
            this._grid.attach(this._toolbar, 0, 0, 1, 1);
    
            //show the  toolbar and window
            this._toolbar.show();
            this._window.show();
        }
    
        //callback function for 'activate' signal
        _onActivate() {
            this._window.present();
        }
    
        //callback function for 'startup' signal
        _onStartup() {
            this._initMenus();
            this._buildUI();
        }
    
        //create the toolbar, its toolbuttons and their actions
        _createToolbar() {
    
            this._toolbar = new Gtk.Toolbar();
            this._toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR);
    
            //create the "New" ToolButton and its SimpleAction.
            //Using actions allows you to add them to the app menu
            //without duplicating code.
            let newAction = new Gio.SimpleAction({ name: 'new'});
            newAction.connect('activate', () =&gt; { this._newCB(); });
            this.application.add_action(newAction);//note: this action is added to the app
    
            this._newButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_NEW);
            this._newButton.is_important = true;
            this._toolbar.add(this._newButton);
            this._newButton.show();
            this._newButton.action_name = "app.new";
    
            //create the "Open" ToolButton and its SimpleAction
            let openAction = new Gio.SimpleAction({ name: 'open'});
            openAction.connect('activate', () =&gt; { this._openCB(); });
            this.application.add_action(openAction);
    
            this._openButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_OPEN);
            this._openButton.is_important = true;
            this._toolbar.add(this._openButton);
            this._openButton.show();
            this._openButton.action_name = "app.open";
    
            //create the "Undo" ToolButton and its SimpleAction
            let undoAction = new Gio.SimpleAction({ name: 'undo'});
            undoAction.connect('activate', () =&gt; { this._undoCB(); });
            this._window.add_action(undoAction);//note this action is added to the window
    
            this._undoButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_UNDO);
            this._undoButton.is_important = true;
            this._toolbar.add(this._undoButton);
            this._undoButton.show();
            this._undoButton.action_name = "win.undo";
    
            //create the "Fullscreen" ToolButton and its SimpleAction
            let fullscreenToggleAction = new Gio.SimpleAction ({ name: 'fullscreenToggle' });
            fullscreenToggleAction.connect('activate', () =&gt; {
                this._fullscreenToggleCB();
            });
            this._window.add_action(fullscreenToggleAction);
    
            this._fullscreenButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_FULLSCREEN);
            this._fullscreenButton.is_important = true;
            this._toolbar.add(this._fullscreenButton);
            this._fullscreenButton.show();
            this._fullscreenButton.action_name = "win.fullscreenToggle";
    
            //create the "leaveFullscreen" ToolButton, and set the action name to "win.fullscreenToggle"
            this._leaveFullscreenButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_LEAVE_FULLSCREEN);
            this._leaveFullscreenButton.is_important = true;
            this._toolbar.add(this._leaveFullscreenButton);
            this._leaveFullscreenButton.action_name = "win.fullscreenToggle";
        }
    
        _initMenus() {
            let menu = new Gio.Menu();
            menu.append("New", 'app.new');
            menu.append("Open", 'app.open');
            menu.append("Quit", 'app.quit');
    
            this.application.set_app_menu(menu);
    
            let quitAction = new Gio.SimpleAction({name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
            this.application.add_action(quitAction);
        }
    
        _newCB() {
            print("You clicked 'New'.");
        }
    
        _openCB() {
            print("You clicked 'Open'.");
        }
    
        _undoCB() {
            print ("You clicked 'Undo'.");
        }
    
        _fullscreenToggleCB() {
            if ((this._window.get_window().get_state() &amp; Gdk.WindowState.FULLSCREEN) != 0 ) {
                  this._window.unfullscreen();
                  this._leaveFullscreenButton.hide();
                  this._fullscreenButton.show();
            } else {
                 this._window.fullscreen();
                 this._fullscreenButton.hide();
                 this._leaveFullscreenButton.show();
            }
        }
    };
    
    //run the application
    let app = new Application();
    app.application.run(ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gdk = '3.0';
    imports.gi.versions.Gtk = '3.0';
    
    const Gdk = imports.gi.Gdk;
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class Application {
    
        // Vytvoří aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.myapp',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
           // Napojí signály "activate" a "startup" k funkcím zpětného volání
           this.application.connect('activate', this._onActivate.bind(this));
           this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Vytvoří uživatelské rozhraní (v tomto případě jen ApplicationWindow)
        _buildUI() {
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Toolbar Example",
                default_height: 200,
                default_width: 400
            });
    
            this._grid = new Gtk.Grid();
            this._window.add(this._grid);
            this._grid.show();
    
            this._createToolbar();
            this._toolbar.set_hexpand(true);
            this._grid.attach(this._toolbar, 0, 0, 1, 1);
    
            // Zobrazí nástrojovou lištu a okno
            this._toolbar.show();
            this._window.show();
        }
    
        // Funkce zpětného volání pro signál "activate"
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup"
        _onStartup() {
            this._initMenus();
            this._buildUI();
        }
    
        // Vytvoří nástrojovou lištu, její tlačítka a její akce
        _createToolbar() {
    
            this._toolbar = new Gtk.Toolbar();
            this._toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR);
    
            // Vytvoří nástrojové tlačítko „New“ a jeho SimpleAction.
            // Použití akce vám umožní přidat jej do aplikační nabídky 
            // bez duplikování kódu.
            let newAction = new Gio.SimpleAction({ name: 'new'});
            newAction.connect('activate', () =&gt; { this._newCB(); });
            this.application.add_action(newAction);//note: this action is added to the app
    
            this._newButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_NEW);
            this._newButton.is_important = true;
            this._toolbar.add(this._newButton);
            this._newButton.show();
            this._newButton.action_name = "app.new";
    
            // Vytvoří nástrojové tlačítko „Open“ a jeho SimpleAction
            let openAction = new Gio.SimpleAction({ name: 'open'});
            openAction.connect('activate', () =&gt; { this._openCB(); });
            this.application.add_action(openAction);
    
            this._openButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_OPEN);
            this._openButton.is_important = true;
            this._toolbar.add(this._openButton);
            this._openButton.show();
            this._openButton.action_name = "app.open";
    
            // Vytvoří nástrojové tlačítko „Undo“ a jeho SimpleAction.
            let undoAction = new Gio.SimpleAction({ name: 'undo'});
            undoAction.connect('activate', () =&gt; { this._undoCB(); });
            this._window.add_action(undoAction);//note this action is added to the window
    
            this._undoButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_UNDO);
            this._undoButton.is_important = true;
            this._toolbar.add(this._undoButton);
            this._undoButton.show();
            this._undoButton.action_name = "win.undo";
    
            // Vytvoří nástrojové tlačítko „Fullscreen“ a a jeho SimpleAction
            let fullscreenToggleAction = new Gio.SimpleAction ({ name: 'fullscreenToggle' });
            fullscreenToggleAction.connect('activate', () =&gt; {
                this._fullscreenToggleCB();
            });
            this._window.add_action(fullscreenToggleAction);
    
            this._fullscreenButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_FULLSCREEN);
            this._fullscreenButton.is_important = true;
            this._toolbar.add(this._fullscreenButton);
            this._fullscreenButton.show();
            this._fullscreenButton.action_name = "win.fullscreenToggle";
    
            // Vytvoří nástrojové tlačítko „leaveFullscreen“ a nastaví název akce na „win.fullscreenToggle“
            this._leaveFullscreenButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_LEAVE_FULLSCREEN);
            this._leaveFullscreenButton.is_important = true;
            this._toolbar.add(this._leaveFullscreenButton);
            this._leaveFullscreenButton.action_name = "win.fullscreenToggle";
        }
    
        _initMenus() {
            let menu = new Gio.Menu();
            menu.append("New", 'app.new');
            menu.append("Open", 'app.open');
            menu.append("Quit", 'app.quit');
    
            this.application.set_app_menu(menu);
    
            let quitAction = new Gio.SimpleAction({name: 'quit' });
            quitAction.connect('activate', () =&gt; { this._window.destroy(); });
            this.application.add_action(quitAction);
        }
    
        _newCB() {
            print("You clicked 'New'.");
        }
    
        _openCB() {
            print("You clicked 'Open'.");
        }
    
        _undoCB() {
            print ("You clicked 'Undo'.");
        }
    
        _fullscreenToggleCB() {
            if ((this._window.get_window().get_state() &amp; Gdk.WindowState.FULLSCREEN) != 0 ) {
                  this._window.unfullscreen();
                  this._leaveFullscreenButton.hide();
                  this._fullscreenButton.show();
            } else {
                 this._window.fullscreen();
                 this._fullscreenButton.hide();
                 this._leaveFullscreenButton.show();
            }
        }
    };
    
    // Spustí aplikaci
    let app = new Application();
    app.application.run(ARGV);

note: (itstool) path: info/desc
en: A bar of buttons and other widgets
cs: Lišta s tlačítky a dalšími widgety

note: (itstool) path: page/p
en: An example of toolbar with buttons (from stock icons).
cs: Příklad lišty s tlačítky (se standardními ikonami).

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Gdk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Toolbar Example", application=app)
            self.set_default_size(400, 200)
    
            # a grid to attach the toolbar
            grid = Gtk.Grid()
    
            # a toolbar created in the method create_toolbar (see below)
            toolbar = self.create_toolbar()
            # with extra horizontal space
            toolbar.set_hexpand(True)
            # show the toolbar
            toolbar.show()
    
            # attach the toolbar to the grid
            grid.attach(toolbar, 0, 0, 1, 1)
    
            # add the grid to the window
            self.add(grid)
    
            # create the actions that control the window and connect their signal to a
            # callback method (see below):
    
            # undo
            undo_action = Gio.SimpleAction.new("undo", None)
            undo_action.connect("activate", self.undo_callback)
            self.add_action(undo_action)
    
            # fullscreen
            fullscreen_action = Gio.SimpleAction.new("fullscreen", None)
            fullscreen_action.connect("activate", self.fullscreen_callback)
            self.add_action(fullscreen_action)
    
        # a method to create the toolbar
        def create_toolbar(self):
            # a toolbar
            toolbar = Gtk.Toolbar()
    
            # which is the primary toolbar of the application
            toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
    
            # create a button for the "new" action, with a stock image
            new_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_NEW)
            # label is shown
            new_button.set_is_important(True)
            # insert the button at position in the toolbar
            toolbar.insert(new_button, 0)
            # show the button
            new_button.show()
            # set the name of the action associated with the button.
            # The action controls the application (app)
            new_button.set_action_name("app.new")
    
            # button for the "open" action
            open_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_OPEN)
            open_button.set_is_important(True)
            toolbar.insert(open_button, 1)
            open_button.show()
            open_button.set_action_name("app.open")
    
            # button for the "undo" action
            undo_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_UNDO)
            undo_button.set_is_important(True)
            toolbar.insert(undo_button, 2)
            undo_button.show()
            undo_button.set_action_name("win.undo")
    
            # button for the "fullscreen/leave fullscreen" action
            self.fullscreen_button = Gtk.ToolButton.new_from_stock(
                Gtk.STOCK_FULLSCREEN)
            self.fullscreen_button.set_is_important(True)
            toolbar.insert(self.fullscreen_button, 3)
            self.fullscreen_button.set_action_name("win.fullscreen")
    
            # return the complete toolbar
            return toolbar
    
        # callback method for undo
        def undo_callback(self, action, parameter):
            print("You clicked \"Undo\".")
    
        # callback method for fullscreen / leave fullscreen
        def fullscreen_callback(self, action, parameter):
            # check if the state is the same as Gdk.WindowState.FULLSCREEN, which
            # is a bit flag
            is_fullscreen = self.get_window().get_state(
            ) &amp; Gdk.WindowState.FULLSCREEN != 0
            if not is_fullscreen:
                self.fullscreen_button.set_stock_id(Gtk.STOCK_LEAVE_FULLSCREEN)
                self.fullscreen()
            else:
                self.fullscreen_button.set_stock_id(Gtk.STOCK_FULLSCREEN)
                self.unfullscreen()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # create the actions that control the window and connect their signal to a
            # callback method (see below):
    
            # new
            new_action = Gio.SimpleAction.new("new", None)
            new_action.connect("activate", self.new_callback)
            app.add_action(new_action)
    
            # open
            open_action = Gio.SimpleAction.new("open", None)
            open_action.connect("activate", self.open_callback)
            app.add_action(open_action)
    
        # callback method for new
        def new_callback(self, action, parameter):
            print("You clicked \"New\".")
    
        # callback method for open
        def open_callback(self, action, parameter):
            print("You clicked \"Open\".")
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Gdk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Toolbar Example", application=app)
            self.set_default_size(400, 200)
    
            # Mřížka pro připojení nástrojové lišty
            grid = Gtk.Grid()
    
            # Nástrojová lišta vytvořená v metodě create_toolbar (viz dále)
            toolbar = self.create_toolbar()
            # S dodatečným vodorovným místem
            toolbar.set_hexpand(True)
            # Zobrazí nástrojovou lištu
            toolbar.show()
    
            # Připojí nástrojovou lištu do mřížky
            grid.attach(toolbar, 0, 0, 1, 1)
    
            # Přidá mřížku do okna
            self.add(grid)
    
            # Vytvoří akce, které ovládají okno a napojí jejich signály na
            # metody zpětného volání (viz dále):
    
            # Akce "undo"
            undo_action = Gio.SimpleAction.new("undo", None)
            undo_action.connect("activate", self.undo_callback)
            self.add_action(undo_action)
    
            # Akce "fullscreen"
            fullscreen_action = Gio.SimpleAction.new("fullscreen", None)
            fullscreen_action.connect("activate", self.fullscreen_callback)
            self.add_action(fullscreen_action)
    
        # Metoda, která vytvoří nástrojovou lištu
        def create_toolbar(self):
            # Nástrojová lišta
            toolbar = Gtk.Toolbar()
    
            # Jedná se o hlavní nástrojovou lištu aplikace
            toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
    
            # Vytvoří tlačítko pro akci "new", se standardní ikonou
            new_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_NEW)
            # Popisek se zobrazuje
            new_button.set_is_important(True)
            # Vloží tlačítko na pozici na nástrojové liště
            toolbar.insert(new_button, 0)
            # Zobrazí tlačítko
            new_button.show()
            # Nastaví název akce přidružené k tlačítku
            # Tato akce řídí aplikaci (app)
            new_button.set_action_name("app.new")
    
            # Tlačítko pro akci "open"
            open_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_OPEN)
            open_button.set_is_important(True)
            toolbar.insert(open_button, 1)
            open_button.show()
            open_button.set_action_name("app.open")
    
            # Tlačítko pro akci "undo"
            undo_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_UNDO)
            undo_button.set_is_important(True)
            toolbar.insert(undo_button, 2)
            undo_button.show()
            undo_button.set_action_name("win.undo")
    
            # Tlačítko pro akci "fullscreen/leave fullscreen"
            self.fullscreen_button = Gtk.ToolButton.new_from_stock(
                Gtk.STOCK_FULLSCREEN)
            self.fullscreen_button.set_is_important(True)
            toolbar.insert(self.fullscreen_button, 3)
            self.fullscreen_button.set_action_name("win.fullscreen")
    
            # Vrátí kompletní nástrojovou lištu
            return toolbar
    
        # Metoda zpětného volání pro "undo"
        def undo_callback(self, action, parameter):
            print("You clicked \"Undo\".")
    
        # Metoda zpětného volání pro "fullscreen/leave fullscreen"
        def fullscreen_callback(self, action, parameter):
            # Zkontroluje, jestli je stav stejný jako Gdk.WindowState.FULLSCREEN,
            # což je bitový příznak
            is_fullscreen = self.get_window().get_state(
            ) &amp; Gdk.WindowState.FULLSCREEN != 0
            if not is_fullscreen:
                self.fullscreen_button.set_stock_id(Gtk.STOCK_LEAVE_FULLSCREEN)
                self.fullscreen()
            else:
                self.fullscreen_button.set_stock_id(Gtk.STOCK_FULLSCREEN)
                self.unfullscreen()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # Vytvoří akce pro ovládání aplikace a napojí jejich signály na
            # metody zpětného volání (viz dále):
    
            # Akce "new"
            new_action = Gio.SimpleAction.new("new", None)
            new_action.connect("activate", self.new_callback)
            app.add_action(new_action)
    
            # Akce "open"
            open_action = Gio.SimpleAction.new("open", None)
            open_action.connect("activate", self.open_callback)
            app.add_action(open_action)
    
        # Metoda zpětného volání pro "new"
        def new_callback(self, action, parameter):
            print("You clicked \"New\".")
    
        # Metoda zpětného volání pro "open"
        def open_callback(self, action, parameter):
            print("You clicked \"Open\".")
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Toolbar widget
cs: Užitečné metody pro widget Toolbar

note: (itstool) path: section/p
en: In line 32 the signal <code>"activate"</code> from the action <code>undo_action</code> is connected to the callback function <code>undo_callback()</code> using <code><var>action</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 32 je signál <code>"activate"</code> od činnosti <code>undo_action</code> napojen na funkci zpětného volání <code>undo_callback()</code> pomocí <code><var>action</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: Use <code>insert(tool_item, position)</code> to insert the <code>tool_item</code> at <code>position</code>. If <code>position</code> is negative, the item is appended at the end of the toolbar.
cs: Použijte <code>insert(nástrojová_položka, pozice)</code> k vložení <code>nástrojové_položky</code> na <code>pozici</code>. Pokud je <code>pozice</code> záporná, bude položka vložena na konec nástrojové lišty.

note: (itstool) path: item/p
en: <code>get_item_index(tool_item)</code> retrieves the position of <code>tool_item</code> on the toolbar.
cs: <code>get_item_index(tool_item)</code> vrací pozici <code>tool_item</code> na nástrojové liště.

note: (itstool) path: item/p
en: <code>get_n_items()</code> returns the number of items on the toolbar; <code>get_nth_item(position)</code> returns the item in position <code>position</code>.
cs: <code>get_n_items()</code> vrací počet položek na nástrojové liště. <code>get_nth_item(pozice)</code> vrací položku na pozici <code>pozice</code>.

note: (itstool) path: item/p
en: If the toolbar does not have room for all the menu items, and <code>set_show_arrow(True)</code>, the items that do not have room are shown through an overflow menu.
cs: Pokud nástrojová lišta nemá dostatek místa pro všechny položky a je použito <code>set_show_arrow(True)</code>, položky které jdou mimo se zobrazí v nabídce přetékajících položek.

note: (itstool) path: item/p
en: <code>set_icon_size(icon_size)</code> sets the size of icons in the toolbar; <code>icon_size</code> can be one of <code>Gtk.IconSize.INVALID, Gtk.IconSize.MENU, Gtk.IconSize.SMALL_TOOLBAR, Gtk.IconSize.LARGE_TOOLBAR, Gtk.IconSize.BUTTON, Gtk.IconSize.DND, Gtk.IconSize.DIALOG</code>. This should be used only for special-purpose toolbars, normal application toolbars should respect user preferences for the size of icons. <code>unset_icon_size()</code> unsets the preferences set with <code>set_icon_size(icon_size)</code>, so that user preferences are used to determine the icon size.
cs: <code>set_icon_size(velikost_ikony)</code> nastavuje velikost ikony na nástrojové liště. Parametr <code>velikost_ikony</code> může být něco z <code>Gtk.IconSize.INVALID</code>, <code>Gtk.IconSize.MENU</code>, <code>Gtk.IconSize.SMALL_TOOLBAR</code>, <code>Gtk.IconSize.LARGE_TOOLBAR</code>, <code>Gtk.IconSize.BUTTON</code>, <code>Gtk.IconSize.DND</code> nebo <code>Gtk.IconSize.DIALOG</code>. Používat by se to mělo jen pro speciální účely, normálně by nástrojová lišta aplikace měla respektovat uživatelské předvolby pro velikost ikon. <code>unset_icon_size()</code> zruší volbu nastavenou pomocí <code>set_icon_size(velikost_ikony)</code>, takže se k určení velikosti ikon použije uživatelská předvolba.

note: (itstool) path: item/p
en: <code>set_style(style)</code>, where <code>style</code> is one of <code>Gtk.ToolbarStyle.ICONS, Gtk.ToolbarStyle.TEXT, Gtk.ToolbarStyle.BOTH, Gtk.ToolbarStyle.BOTH_HORIZ</code>, sets if the toolbar shows only icons, only text, or both (vertically stacked or alongside each other). To let user preferences determine the toolbar style, and unset a toolbar style so set, use <code>unset_style()</code>.
cs: <code>set_style(styl)</code>, kde <code>styl</code> je jedno z <code>Gtk.ToolbarStyle.ICONS</code>, <code>Gtk.ToolbarStyle.TEXT</code>, <code>Gtk.ToolbarStyle.BOTH</code> nebo <code>Gtk.ToolbarStyle.BOTH_HORIZ</code>, nastavuje, jestli nástrojová lišta zobrazuje jen ikony, jen text nebo obojí (svisle na sobě nebo vedle sebe). Abyste umožňili uživateli předvolby určující styl nástrojové lišty a zrušit již nastavený styl, použijte <code>unset_style()</code>.

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/gdk3/unstable/gdk3-Event-Structures.html#GdkEventWindowState">Event Structures</link>
cs: <link href="http://developer.gnome.org/gdk3/unstable/gdk3-Event-Structures.html#GdkEventWindowState">Struktury událostí</link>

note: (itstool) path: page/code
en: /* This is the Window */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* Instance variables belonging to the window */
    	Gtk.Toolbar toolbar;
    	Gtk.ToolButton new_button;
    	Gtk.ToolButton open_button;
    	Gtk.ToolButton undo_button;
    	Gtk.ToolButton fullscreen_button;
    	Gtk.ToolButton leave_fullscreen_button;
    
    	/* Constructor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Toolbar Example");
    
    		this.set_default_size (400, 200);
    		var grid = new Gtk.Grid ();
    		this.add (grid);
    		grid.show ();
    
    		create_toolbar ();
    		toolbar.set_hexpand (true);
    		grid.attach (toolbar, 0, 0, 1, 1);
    		toolbar.show ();
    
    		/* create the "undo" window action action */
    		var undo_action = new SimpleAction ("undo", null);
    		undo_action.activate.connect (undo_callback);
    		this.add_action (undo_action);
    
    		/* create the "fullscreen" window action */
    		var fullscreen_action = new SimpleAction ("fullscreen", null);
    		fullscreen_action.activate.connect (fullscreen_callback);
    		this.add_action (fullscreen_action);
    	}
    
    	/* This function creates the toolbar, its  ToolButtons,
    	 * and assigns the actions names to the ToolButtons.*/
    	void create_toolbar () {
    		toolbar = new Gtk.Toolbar ();
    		toolbar.get_style_context ().add_class (Gtk.STYLE_CLASS_PRIMARY_TOOLBAR);
    
    		new_button = new Gtk.ToolButton.from_stock (Gtk.Stock.NEW);
    		new_button.is_important = true; //decides whether to show the label
    		toolbar.add (new_button);
    		new_button.show ();
    		new_button.action_name = "app.new";
    
    		open_button = new Gtk.ToolButton.from_stock (Gtk.Stock.OPEN);
    		open_button.is_important = true;
    		toolbar.add (open_button);
    		open_button.show ();
    		open_button.action_name = "app.open";
    
    		undo_button = new Gtk.ToolButton.from_stock (Gtk.Stock.UNDO);
    		undo_button.is_important = true;
    		toolbar.add (undo_button);
    		undo_button.show ();
    		undo_button.action_name = "win.undo";
    
    		fullscreen_button = new Gtk.ToolButton.from_stock (Gtk.Stock.FULLSCREEN);
    		fullscreen_button.is_important = true;
    		toolbar.add (fullscreen_button);
    		fullscreen_button.show ();
    		fullscreen_button.action_name = "win.fullscreen";
    
    		leave_fullscreen_button = new Gtk.ToolButton.from_stock (Gtk.Stock.LEAVE_FULLSCREEN)
    ;
    		leave_fullscreen_button.is_important = true;
    		toolbar.add (leave_fullscreen_button);
    
    		leave_fullscreen_button.action_name = "win.fullscreen";
    	}
    
    	void undo_callback (SimpleAction simple, Variant? parameter) {
    			print ("You clicked \"Undo\".\n");
    	}
    
    	void fullscreen_callback (SimpleAction simple, Variant? parameter) {
    		if ((this.get_window ().get_state () &amp; Gdk.WindowState.FULLSCREEN) != 0) {
    			this.unfullscreen ();
    			leave_fullscreen_button.hide ();
    			fullscreen_button.show ();
    		}
    		else {
    			this.fullscreen ();
    			fullscreen_button.hide ();
    			leave_fullscreen_button.show ();
    		}
    	}
    }
    
    /* This is the application */
    class MyApplication : Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    	protected override void startup () {
    		base.startup ();
    
    		/* Create the "new" action and add it to the app*/
    		var new_action = new SimpleAction ("new", null);
    		new_action.activate.connect (new_callback);
    		this.add_action (new_action);
    
    		/* Create the "open" action, and add it to the app */
    		var open_action = new SimpleAction ("open", null);
    		open_action.activate.connect (open_callback);
    		this.add_action (open_action);
    
    		/* You could also add the action to the app menu
    		 * if you wanted to.
    		 */
    		//var menu = new Menu ();
    		//menu.append ("New", "app.new");
    		//this.app_menu = menu;
    	}
    
    	void new_callback (SimpleAction action, Variant? parameter) {
    		print ("You clicked \"New\".\n");
    	}
    
    	void open_callback (SimpleAction action, Variant? parameter) {
    			print ("You clicked \"Open\".\n");
    	}
    }
    
    /* The main function creates the application and runs it. */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Toto je okno */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* Instance proměnných náležejících k oknu */
    	Gtk.Toolbar toolbar;
    	Gtk.ToolButton new_button;
    	Gtk.ToolButton open_button;
    	Gtk.ToolButton undo_button;
    	Gtk.ToolButton fullscreen_button;
    	Gtk.ToolButton leave_fullscreen_button;
    
    	/* Konstruktor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Toolbar Example");
    
    		this.set_default_size (400, 200);
    		var grid = new Gtk.Grid ();
    		this.add (grid);
    		grid.show ();
    
    		create_toolbar ();
    		toolbar.set_hexpand (true);
    		grid.attach (toolbar, 0, 0, 1, 1);
    		toolbar.show ();
    
    		/* Vytvoří akci okna "undo" */
    		var undo_action = new SimpleAction ("undo", null);
    		undo_action.activate.connect (undo_callback);
    		this.add_action (undo_action);
    
    		/* Vytvoří akci okna "fullscreen" */
    		var fullscreen_action = new SimpleAction ("fullscreen", null);
    		fullscreen_action.activate.connect (fullscreen_callback);
    		this.add_action (fullscreen_action);
    	}
    
    	/* Tato funkce vytvoří nástrojovou lištu, její tlačítka a
    	 * těm přiřadí názvy akcí*/
    	void create_toolbar () {
    		toolbar = new Gtk.Toolbar ();
    		toolbar.get_style_context ().add_class (Gtk.STYLE_CLASS_PRIMARY_TOOLBAR);
    
    		new_button = new Gtk.ToolButton.from_stock (Gtk.Stock.NEW);
    		new_button.is_important = true; //decides whether to show the label
    		toolbar.add (new_button);
    		new_button.show ();
    		new_button.action_name = "app.new";
    
    		open_button = new Gtk.ToolButton.from_stock (Gtk.Stock.OPEN);
    		open_button.is_important = true;
    		toolbar.add (open_button);
    		open_button.show ();
    		open_button.action_name = "app.open";
    
    		undo_button = new Gtk.ToolButton.from_stock (Gtk.Stock.UNDO);
    		undo_button.is_important = true;
    		toolbar.add (undo_button);
    		undo_button.show ();
    		undo_button.action_name = "win.undo";
    
    		fullscreen_button = new Gtk.ToolButton.from_stock (Gtk.Stock.FULLSCREEN);
    		fullscreen_button.is_important = true;
    		toolbar.add (fullscreen_button);
    		fullscreen_button.show ();
    		fullscreen_button.action_name = "win.fullscreen";
    
    		leave_fullscreen_button = new Gtk.ToolButton.from_stock (Gtk.Stock.LEAVE_FULLSCREEN)
    ;
    		leave_fullscreen_button.is_important = true;
    		toolbar.add (leave_fullscreen_button);
    
    		leave_fullscreen_button.action_name = "win.fullscreen";
    	}
    
    	void undo_callback (SimpleAction simple, Variant? parameter) {
    			print ("You clicked \"Undo\".\n");
    	}
    
    	void fullscreen_callback (SimpleAction simple, Variant? parameter) {
    		if ((this.get_window ().get_state () &amp; Gdk.WindowState.FULLSCREEN) != 0) {
    			this.unfullscreen ();
    			leave_fullscreen_button.hide ();
    			fullscreen_button.show ();
    		}
    		else {
    			this.fullscreen ();
    			fullscreen_button.hide ();
    			leave_fullscreen_button.show ();
    		}
    	}
    }
    
    /* Toto je aplikace */
    class MyApplication : Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    	protected override void startup () {
    		base.startup ();
    
    		/* Vytvoří akci "new" a přidá ji do aplikace */
    		var new_action = new SimpleAction ("new", null);
    		new_action.activate.connect (new_callback);
    		this.add_action (new_action);
    
    		/* Vytvoří akci "open" a přidá ji do aplikace */
    		var open_action = new SimpleAction ("open", null);
    		open_action.activate.connect (open_callback);
    		this.add_action (open_action);
    
    		/* Jestli chcete, můžete akci přidat i do aplikační
    		 * nabídky
    		 */
    		//var menu = new Menu ();
    		//menu.append ("New", "app.new");
    		//this.app_menu = menu;
    	}
    
    	void new_callback (SimpleAction action, Variant? parameter) {
    		print ("You clicked \"New\".\n");
    	}
    
    	void open_callback (SimpleAction action, Variant? parameter) {
    			print ("You clicked \"Open\".\n");
    	}
    }
    
    /* Funkce main vytvoří aplikaci a spustí ji */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }

[ctx: text]
note: (itstool) path: info/title
en: Toolbar created using Glade (Python)
cs: Nástrojová lišta vytvořená pomocí Glade (Python)

note: (itstool) path: page/title
en: Toolbar created using Glade
cs: Toolbar (vytvořený pomocí Glade)

note: (itstool) path: page/p
en: This example is similar to <link xref="toolbar.py"/>, except we use Glade to create the toolbar in an XML .ui file.
cs: Tento příklad je podobný příkladu <link xref="toolbar.py"/> s tím rozdílem, že k vytvoření nástrojové lišty v souboru .ui ve formátu XML použijeme návrhář Glade.

note: (itstool) path: section/title
en: Creating the toolbar with Glade
cs: Vytvoření nástrojové lišty pomocí Glade

note: (itstool) path: section/p (itstool) path: page/p
en: To create the toolbar using the <link href="http://glade.gnome.org/">Glade Interface Designer</link>:
cs: Když chcete vytvořit nástrojovou lištu pomocí <link href="http://glade.gnome.org/">návrháře rozhraní Glade</link>:

note: (itstool) path: item/p
en: Open Glade, and save the file as <file>toolbar_builder.ui</file>
cs: Otevřete Glade a uložte soubor jako <file>toolbar_builder.ui</file>.

note: (itstool) path: item/p
en: <media type="image" src="media/glade_ui.png" width="900"> Screenshot of Glade ui </media>
cs: <media type="image" src="media/glade_ui.png" width="900">Snímek obrazovky s uživatelským rozhraním Glade</media>

note: (itstool) path: item/p
en: Under <gui>Containers</gui> on the left hand side, right click on the toolbar icon and select <gui>Add widget as toplevel</gui>.
cs: V <gui>Kontejnerech</gui> na levé straně klikněte pravým tlačítkem na ikonu nástrojové lišty a vyberte <gui>Přidat widget do nejvyšší úrovně</gui>.

note: (itstool) path: item/p
en: <media type="image" src="media/glade_select_toolbar.png"> Screenshot of toolbar icon in Glade ui </media>
cs: <media type="image" src="media/glade_select_toolbar.png">Snímek obrazovky s ikonou nástrojové lišty v uživatelském rozhraní Glade</media>

note: (itstool) path: item/p
en: Under the <gui>General</gui> tab on the bottom right, change the <gui>Name</gui> to <input>toolbar</input> and <gui>Show Arrow</gui> to <gui>No</gui>.
cs: Na kartě <gui>Obecné</gui> vpravo dole změňte <gui>Název</gui> na <input>toolbar</input> a <gui>Zobrazovat šipku</gui> na <gui>Ne</gui>.

note: (itstool) path: item/p
en: <media type="image" src="media/glade_toolbar_general.png"> Screenshot of General tab </media>
cs: <media type="image" src="media/glade_toolbar_general.png">Snímek obrazovky s kartou Obecné</media>

note: (itstool) path: item/p
en: Under the <gui>Common</gui> tab, set <gui>Horizontal Expand</gui> to <gui>Yes</gui>.
cs: Na kartě <gui>Běžné</gui> nastavte <gui>Roztáhnout vodorovně</gui> na <gui>Ano</gui>.

note: (itstool) path: item/p
en: <media type="image" src="media/glade_toolbar_common.png"> Screenshot of Common tab </media>
cs: <media type="image" src="media/glade_toolbar_common.png">Snímek obrazovky s kartou Běžné</media>

note: (itstool) path: item/p
en: Right click on the toolbar in the top right and select <gui>Edit</gui>. The <gui>Tool Bar Editor</gui> window will appear.
cs: Klikněte pravým tlačítkem na „toolbar“ vpravo nahoře a vyberte <gui>Upravit</gui>. Objeví se okno <gui>Editor nástrojové lišty</gui>.

note: (itstool) path: item/p
en: <media type="image" src="media/glade_toolbar_edit.png"> Screenshot of where to right click to edit toolbar. </media>
cs: <media type="image" src="media/glade_toolbar_edit.png">Snímek obrazovky, na kterém je kliknuto pravým tlačítkem kvůli úpravě nástrojové lišty</media>

note: (itstool) path: item/p
en: We want to add 5 ToolButtons: New, Open, Undo, Fullscreen and Leave Fullscreen. First, we will add the New ToolButton.
cs: Chceme přidat 5 tlačítek ToolButton: „New“, „Open“, „Undo“, „Fullscreen“ a „Leave Fullscreen“. Nejprve přidáme ToolButton „New“.

note: (itstool) path: item/p
en: Under <gui>Hierarchy</gui> tab, click <gui>Add</gui>.
cs: Na kartě <gui>Hierarchie</gui> klikněte na <gui>Přidat</gui>.

note: (itstool) path: item/p
en: Change the name of the ToolItem to <input>new_button</input>.
cs: Změňte název „toolbutton1“ na „new_button“.

note: (itstool) path: item/p
en: Scroll down and set <gui>Is important</gui> to <gui>Yes</gui>. This will cause the label of the ToolButton to be shown, when you view the toolbar.
cs: Posuňte se dolů a nastavte <gui>Je důležitá</gui> na <gui>Ano</gui>. To způsobí, že když je zobrazena nástrojová lišta, bude nástrojovém tlačítku zobrazen popisek.

note: (itstool) path: item/p
en: Enter the <gui>action name</gui>: <input>app.new</input>.
cs: Zadejte <gui>Název akce</gui>: <input>app.new</input>.

note: (itstool) path: item/p
en: Change the <gui>Label</gui> to <input>New</input>.
cs: Změňte <gui>Popisek</gui> na <input>New</input>.

note: (itstool) path: item/p
en: Select the <gui>New</gui> Stock Id from the drop down menu, or type <input>gtk-new</input>.
cs: V rozbalovacím seznamu zvolte <gui>New</gui> jako <gui>Standadní ID</gui> nebo napište <input>gtk-new</input>.

note: (itstool) path: item/p
en: Repeat the above steps for the remaining ToolButtons, with the following properties:
cs: Opakujte předchozí kroky pro zbývající tlačítka ToolButton s následujícími vlastnostmi:

note: (itstool) path: td/p
en: Is important
cs: Je důležitá

note: (itstool) path: td/p
en: Action name
cs: Název akce

note: (itstool) path: td/p
en: Stock Id
cs: Standardní ID

note: (itstool) path: td/p
en: Yes
cs: Ano

note: (itstool) path: item/p
en: Close the <gui>Tool Bar Editor</gui>.
cs: Zavřete <gui>Editor panelu nástrojů</gui>.

note: (itstool) path: item/p
en: When our program will first start, we do not want the <gui>Leave Fullscreen</gui> ToolButton to be visible, since the application will not be in fullscreen mode. You can set this in the <gui>Common</gui> tab, by clicking the <gui>Visible</gui> property to <gui>No</gui>. The ToolButton will still appear in the interface designer, but will behave correctly when the file is loaded into your program code. Note that the method <code>show_all()</code> would override this setting - so in the code we have to use <code>show()</code> separately on all the elements.
cs: Když svůj program spustíte, nechcete aby bylo zobrazené nástrojové tlačítko <gui>Leave Fullscreen</gui>, protože aplikace není v režimu celé obrazovky. Můžete to nastavit na kartě <gui>Běžné</gui>, kde přepnete vlastnost <gui>Viditelný</gui> na <gui>Ne</gui>. Nástrojové tlačítko sice bude pořád viditelné v návrháři rozhraní, ale po načtení do vašeho programu se bude chovat podle očekávání. Upozorňujeme, že jakékoliv použití metody <code>show_all()</code> by toto nastavení přepsalo, takže v celém kódu musíme používat <code>show()</code> zvlášť pro každý prvek.

note: (itstool) path: item/p
en: <media type="image" src="media/glade_visible_no.png"> Setting the visible property to No </media>
cs: <media type="image" src="media/glade_visible_no.png">Nastavení vlastnosti Viditelná na Ne</media>

note: (itstool) path: item/p
en: Save your work, and close Glade.
cs: Uložte svoji práci a zavřete Glade.

note: (itstool) path: item/p
en: The XML file created by Glade is shown below. This is the description of the toolbar. At the time of this writing, the option to add the class Gtk.STYLE_CLASS_PRIMARY_TOOLBAR in the Glade Interface did not exist. We can manually add this to the XML file. To do this, add the following XML code at line 9 of <file>toolbar_builder.ui</file>:
cs: Soubor XML vytvořený v <app>Glade</app> je zobrazen níže. Jedná se o popis nástrojové lišty. V době, kdy bylo toto psáno, neexistovala v uživatelském rozhraní <app>Glade</app> volba pro přidání třídy <code>Gtk.STYLE_CLASS_PRIMARY_TOOLBAR</code>. Můžeme ji ale do souboru XML přidat ručně. Udělá se to přidáním následujícího kódu XML na řádek 9 v <file>toolbar_builder.ui</file>:

note: (itstool) path: item/p
en: If you do not add this, the program will still work fine. The resulting toolbar will however look slightly different then the screenshot at the top of this page.
cs: Pokud tuto část nepřidáte, bude program i tak fungovat dobře. Akorát výsledná nástrojová lišty bude vypadat lehce odlišně než ta na snímku obrazovky na začátku této stránky.

note: (itstool) path: section/p (itstool) path: page/p
en: We now create the code below, which adds the toolbar from the file we just created.
cs: Nyní vytvoříme kód zobrazený níže, který přidá nástrojovou lištu ze souboru, který jsme právě vytvořili.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Gdk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Toolbar Example", application=app)
            self.set_default_size(400, 200)
    
            # a grid to attach the toolbar (see below)
            grid = Gtk.Grid()
            self.add(grid)
            # we have to show the grid (and therefore the toolbar) with show(),
            # as show_all() would show also the buttons in the toolbar that we want to
            # be hidden (such as the leave_fullscreen button)
            grid.show()
    
            # a builder to add the UI designed with Glade to the grid:
            builder = Gtk.Builder()
            # get the file (if it is there)
            try:
                builder.add_from_file("toolbar_builder.ui")
            except:
                print("file not found")
                sys.exit()
            # and attach it to the grid
            grid.attach(builder.get_object("toolbar"), 0, 0, 1, 1)
    
            # two buttons that will be used later in a method
            self.fullscreen_button = builder.get_object("fullscreen_button")
            self.leave_fullscreen_button = builder.get_object(
                "leave_fullscreen_button")
    
            # create the actions that control the window, connect their signal to a
            # callback method (see below), add the action to the window:
    
            # undo
            undo_action = Gio.SimpleAction.new("undo", None)
            undo_action.connect("activate", self.undo_callback)
            self.add_action(undo_action)
    
            # and fullscreen
            fullscreen_action = Gio.SimpleAction.new("fullscreen", None)
            fullscreen_action.connect("activate", self.fullscreen_callback)
            self.add_action(fullscreen_action)
    
        # callback for undo
        def undo_callback(self, action, parameter):
            print("You clicked \"Undo\".")
    
        # callback for fullscreen
        def fullscreen_callback(self, action, parameter):
            # check if the state is the same as Gdk.WindowState.FULLSCREEN, which
            # is a bit flag
            is_fullscreen = self.get_window().get_state(
            ) &amp; Gdk.WindowState.FULLSCREEN != 0
            if is_fullscreen:
                self.unfullscreen()
                self.leave_fullscreen_button.hide()
                self.fullscreen_button.show()
            else:
                self.fullscreen()
                self.fullscreen_button.hide()
                self.leave_fullscreen_button.show()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            # show the window - with show() not show_all() because that would show also
            # the leave_fullscreen button
            win.show()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # actions that control the application: create, connect their signal to a
            # callback method (see below), add the action to the application
    
            # new
            new_action = Gio.SimpleAction.new("new", None)
            new_action.connect("activate", self.new_callback)
            app.add_action(new_action)
    
            # open
            open_action = Gio.SimpleAction.new("open", None)
            open_action.connect("activate", self.open_callback)
            app.add_action(open_action)
    
        # callback for new
        def new_callback(self, action, parameter):
            print("You clicked \"New\".")
    
        # callback for open
        def open_callback(self, action, parameter):
            print("You clicked \"Open\".")
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Gdk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Toolbar Example", application=app)
            self.set_default_size(400, 200)
    
            # Mřížka pro připojení nástrojové lišty (viz dále)
            grid = Gtk.Grid()
            self.add(grid)
            # Musí zobrazit mřížku (a tím nástrojovou lištu) pomocí show(),
            # protože show_all() by zobrazilo a tlačítka na liště, která ale
            # chceme skrytá (kvůli tlačítku leave_fullscreen)
            grid.show()
    
            # Builder pro přidání návrhu uživatelského rozhraní navrženého
            # v Glade do mřížky:
            builder = Gtk.Builder()
            # Získá soubor (pokud existuje)
            try:
                builder.add_from_file("toolbar_builder.ui")
            except:
                print("file not found")
                sys.exit()
            # A připojí jej do mřížky
            grid.attach(builder.get_object("toolbar"), 0, 0, 1, 1)
    
            # Dvě tlačítka, která budo použita později v metodě
            self.fullscreen_button = builder.get_object("fullscreen_button")
            self.leave_fullscreen_button = builder.get_object(
                "leave_fullscreen_button")
    
            # Vytvoří akce, které ovládají okno, napojí jejich signály na metodu
            # zpětného volání (viz dále), přidá akce do okna:
    
            # Akce "undo"
            undo_action = Gio.SimpleAction.new("undo", None)
            undo_action.connect("activate", self.undo_callback)
            self.add_action(undo_action)
    
            # Akce "fullscreen"
            fullscreen_action = Gio.SimpleAction.new("fullscreen", None)
            fullscreen_action.connect("activate", self.fullscreen_callback)
            self.add_action(fullscreen_action)
    
        # Zpětné volání pro "undo"
        def undo_callback(self, action, parameter):
            print("You clicked \"Undo\".")
    
        # Zpětné volání pro "fullscreen"
        def fullscreen_callback(self, action, parameter):
            # Zkontroluje, jestli je stav stejný jako Gdk.WindowState.FULLSCREEN,
            # což je bitový příznak
            is_fullscreen = self.get_window().get_state(
            ) &amp; Gdk.WindowState.FULLSCREEN != 0
            if is_fullscreen:
                self.unfullscreen()
                self.leave_fullscreen_button.hide()
                self.fullscreen_button.show()
            else:
                self.fullscreen()
                self.fullscreen_button.hide()
                self.leave_fullscreen_button.show()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            # Zobrazí okno pomocí show(), ne show_all(), protože to by zobrazilo
            # také tlačítko leave_fullscreen
            win.show()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            # Akce, které ovládají aplikace: vytvoří je, napojí jejich signály na
            # metody zpětného volání (viz dále), přidá akce do aplikace
    
            # Akce "new"
            new_action = Gio.SimpleAction.new("new", None)
            new_action.connect("activate", self.new_callback)
            app.add_action(new_action)
    
            # Akce "open"
            open_action = Gio.SimpleAction.new("open", None)
            open_action.connect("activate", self.open_callback)
            app.add_action(open_action)
    
        # Zpětné volání pro "new"
        def new_callback(self, action, parameter):
            print("You clicked \"New\".")
    
        # Zpětné volání pro "open"
        def open_callback(self, action, parameter):
            print("You clicked \"Open\".")
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for Gtk.Builder
cs: Užitečné metody pro Gtk.Builder

note: (itstool) path: section/p
en: For the useful methods for a Toolbar widget, see <link xref="toolbar.py"/>
cs: Na užitečné metody pro widget Toolbar se podívejte do kapitoly <link xref="toolbar.py"/>

note: (itstool) path: section/p
en: Gtk.Builder builds an interface from an XML UI definition.
cs: Gtk.Builder sestaví uživatelské rozhraní z definice ve formátu XML.

note: (itstool) path: item/p
en: <code>add_from_file(filename)</code> loads and parses the given file and merges it with the current contents of the Gtk.Builder.
cs: <code>add_from_file(název_souboru)</code> načte a zpracuje zadaný soubor a sloučí jej s aktuálním obsahem v Gtk.Builder.

note: (itstool) path: item/p
en: <code>add_from_string(string)</code> parses the given string and merges it with the current contents of the Gtk.Builder.
cs: <code>add_from_string(řetězec)</code> zpracuje zadaný řetězec a sloučí jej s aktuálním obsahem v Gtk.Builder.

note: (itstool) path: item/p
en: <code>add_objects_from_file(filename, object_ids)</code> is the same as <code>add_from_file()</code>, but it loads only the objects with the ids given in the <code>object_id</code>s list.
cs: <code>add_objects_from_file(název_souboru, id_objektů)</code> je stejná jako <code>add_from_file()</code>, akorát že načte jen objekty, jejichž ID je uvedeno v seznamu <code>id_objektů</code>.

note: (itstool) path: item/p
en: <code>add_objects_from_string(string, object_ids)</code> is the same as <code>add_from_string()</code>, but it loads only the objects with the ids given in the <code>object_id</code>s list.
cs: <code>add_objects_from_string(řetězec, id_objektů)</code> je stejná jako <code>add_from_string()</code>, akorát že načte jen objekty, jejichž ID je uvedeno v seznamu <code>id_objektů</code>.

note: (itstool) path: item/p
en: <code>get_object(object_id)</code> retrieves the widget with the id <code>object_id</code> from the loaded objects in the builder.
cs: <code>get_object(id_objektu)</code> získá widget s ID <code>id_objektu</code> ze seznamu načtených objektů v Gtk.Builder.

note: (itstool) path: item/p
en: <code>get_objects()</code> returns all loaded objects.
cs: <code>get_objects()</code> vrátí všechny načtené objekty.

note: (itstool) path: item/p
en: <code>connect_signals(handler_object)</code> connects the signals to the methods given in the <code>handler_object</code>. This can be any object which contains keys or attributes that are called like the signal handler names given in the interface description, e.g. a class or a dict. In line 39 the signal <code>"activate"</code> from the action <code>undo_action</code> is connected to the callback function <code>undo_callback()</code> using <code><var>action</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: <code>connect_signals(obsluhující_objekt)</code> napojí signál na metodu zadanou v <code>obsluhující_objekt</code>. Může se jednat o libovolný objekt obsahující klíče a atributy, které jsou volány podobně jako název obsluhy signálu zadaný v popisu rozhraní, např. třída nebo slovník. Na řádku 39 je signál <code>"activate"</code> z akce <code>undo_action</code> napojen na funkci zpětného volání <code>undo_callback()</code> pomocí <code><var>action</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

[ctx: text]
note: (itstool) path: info/title
en: Toolbar created using Glade (Vala)
cs: Nástrojová lišta vytvořená pomocí Glade (Vala)

note: (itstool) path: page/p
en: This example is similar to <link xref="toolbar.vala"/>, except we use Glade to create the toolbar in an XML ui file.
cs: Tento příklad je podobný na <link xref="toolbar.vala"/> s tím rozdílem, že k vytvoření nástrojové lišty v souboru .ui ve formátu XML použijeme návrhář Glade.

note: (itstool) path: item/p
en: When our program will first start, we don't want the <gui>Leave Fullscreen</gui> ToolButton to be visible, since the application will not be in fullscreen mode. You can set this in the <gui>Common</gui> tab, by clicking the <gui>Visible</gui> property to <gui>No</gui>. The ToolButton will still appear in the interface designer, but will behave correctly when the file is loaded into your program code.
cs: Když svůj program spustíte, nechcete aby bylo zobrazené nástrojové tlačítko <gui>Leave Fullscreen</gui>, protože aplikace není v režimu celé obrazovky. Můžete to nastavit na kartě <gui>Běžné</gui>, kde přepnete vlastnost <gui>Viditelný</gui> na <gui>Ne</gui>. Nástrojové tlačítko si bude pořád viditelné v návrháři rozhraní, ale po načtení do vašeho programu se bude chovat podle očekávání.

note: (itstool) path: page/code
en: /* This is the Window */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* Declare these two ToolButtons, as we will get them
    	 * from the ui file (see lines 32 and 33), so we can
    	 * hide() and show() them as needed.*/
    	Gtk.ToolButton fullscreen_button;
    	Gtk.ToolButton leave_fullscreen_button;
    
    	/* Constructor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Toolbar Example");
    
    		this.set_default_size (400, 200);
    		var grid = new Gtk.Grid ();
    		this.add (grid);
    		grid.show ();
    
    		/* add the toolbar from the ui file */
    		var builder = new Gtk.Builder ();
    		try {
    			builder.add_from_file ("toolbar_builder.ui");
    		}
    		/* Handle the exception */
    		catch (Error e) {
    			error ("Unable to load file: %s", e.message);
    		}
    
    		grid.attach (builder.get_object ("toolbar") as Gtk.Toolbar, 0, 0, 1, 1);
    
    		/* get these objects from the ui file so we can toggle between them */
    		fullscreen_button = builder.get_object ("fullscreen_button") as Gtk.ToolButton;
    		leave_fullscreen_button = builder.get_object ("leave_fullscreen_button") as Gtk.ToolButton;
    
    		/* create the "undo" window action action */
    		var undo_action = new SimpleAction ("undo", null);
    		undo_action.activate.connect (undo_callback);
    		this.add_action (undo_action);
    
    		/* create the "fullscreen" window action */
    		var fullscreen_action = new SimpleAction ("fullscreen", null);
    		fullscreen_action.activate.connect (fullscreen_callback);
    		this.add_action (fullscreen_action);
    	}
    
    	void undo_callback (SimpleAction simple, Variant? parameter) {
    			print ("You clicked \"Undo\".\n");
    	}
    
    	void fullscreen_callback (SimpleAction simple, Variant? parameter) {
    		if ((this.get_window ().get_state () &amp; Gdk.WindowState.FULLSCREEN) != 0) {
    			this.unfullscreen ();
    			leave_fullscreen_button.hide ();
    			fullscreen_button.show ();
    		}
    		else {
    			this.fullscreen ();
    			fullscreen_button.hide ();
    			leave_fullscreen_button.show ();
    		}
    	}
    }
    
    /* This is the application */
    class MyApplication : Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    	protected override void startup () {
    		base.startup ();
    
    		/* Create the "new" action and add it to the app*/
    		var new_action = new SimpleAction ("new", null);
    		new_action.activate.connect (new_callback);
    		this.add_action (new_action);
    
    		/* Create the "open" action, and add it to the app */
    		var open_action = new SimpleAction ("open", null);
    		open_action.activate.connect (open_callback);
    		this.add_action (open_action);
    
    		/* You could also add the action to the app menu
    		 * if you wanted to.
    		 */
    		//var menu = new Menu ();
    		//menu.append ("New", "app.new");
    		//this.app_menu = menu;
    	}
    
    	void new_callback (SimpleAction action, Variant? parameter) {
    		print ("You clicked \"New\".\n");
    	}
    
    	void open_callback (SimpleAction action, Variant? parameter) {
    			print ("You clicked \"Open\".\n");
    	}
    }
    
    /* The main function creates the application and runs it. */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Toto je okno */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* Deklarace dvou widgetů ToolButton, protože je získáme
    	 * ze souboru .ui (viz řádky 32 a 33), tak abchom je mohli
    	 * podle potřeby skrýt a zobrazit */
    	Gtk.ToolButton fullscreen_button;
    	Gtk.ToolButton leave_fullscreen_button;
    
    	/* Konstruktor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Toolbar Example");
    
    		this.set_default_size (400, 200);
    		var grid = new Gtk.Grid ();
    		this.add (grid);
    		grid.show ();
    
    		/* Přidá nástrojovou lištu ze souboru .ui */
    		var builder = new Gtk.Builder ();
    		try {
    			builder.add_from_file ("toolbar_builder.ui");
    		}
    		/* Obsluha výjimky */
    		catch (Error e) {
    			error ("Unable to load file: %s", e.message);
    		}
    
    		grid.attach (builder.get_object ("toolbar") as Gtk.Toolbar, 0, 0, 1, 1);
    
    		/* Získá tyto objekty ze souboru .ui, takže se můžeme mezi nimi přepínat */
    		fullscreen_button = builder.get_object ("fullscreen_button") as Gtk.ToolButton;
    		leave_fullscreen_button = builder.get_object ("leave_fullscreen_button") as Gtk.ToolButton;
    
    		/* Vytvoří akci "undo" (akce okna) */
    		var undo_action = new SimpleAction ("undo", null);
    		undo_action.activate.connect (undo_callback);
    		this.add_action (undo_action);
    
    		/* Vytvoří akci "fullscreen" (akce okna) */
    		var fullscreen_action = new SimpleAction ("fullscreen", null);
    		fullscreen_action.activate.connect (fullscreen_callback);
    		this.add_action (fullscreen_action);
    	}
    
    	void undo_callback (SimpleAction simple, Variant? parameter) {
    			print ("You clicked \"Undo\".\n");
    	}
    
    	void fullscreen_callback (SimpleAction simple, Variant? parameter) {
    		if ((this.get_window ().get_state () &amp; Gdk.WindowState.FULLSCREEN) != 0) {
    			this.unfullscreen ();
    			leave_fullscreen_button.hide ();
    			fullscreen_button.show ();
    		}
    		else {
    			this.fullscreen ();
    			fullscreen_button.hide ();
    			leave_fullscreen_button.show ();
    		}
    	}
    }
    
    /* Toto je aplikace */
    class MyApplication : Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    	protected override void startup () {
    		base.startup ();
    
    		/* Vytvoří akci "new" a přidá ji do aplikace */
    		var new_action = new SimpleAction ("new", null);
    		new_action.activate.connect (new_callback);
    		this.add_action (new_action);
    
    		/* Vytvoří akci "open" a přidá ji do aplikace */
    		var open_action = new SimpleAction ("open", null);
    		open_action.activate.connect (open_callback);
    		this.add_action (open_action);
    
    		/* Kdbyste chtěli, mohli byste akci přidat i do aplikační
    		 * nabídky
    		 */
    		//var menu = new Menu ();
    		//menu.append ("New", "app.new");
    		//this.app_menu = menu;
    	}
    
    	void new_callback (SimpleAction action, Variant? parameter) {
    		print ("You clicked \"New\".\n");
    	}
    
    	void open_callback (SimpleAction action, Variant? parameter) {
    			print ("You clicked \"Open\".\n");
    	}
    }
    
    /* Funkce main vytvoří aplikaci a spustí ji */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: Add tips to your widgets
cs: Přidání vysvětlivek do vašich widgetů

note: (itstool) path: page/p
en: A toolbar with a tooltip (with an image) for a button.
cs: Nástrojová lišta s vysvětlivkami (s obrázky) u tlačítek.

note: (itstool) path: note/p
en: This example builds on the <link xref="toolbar.c">Toolbar</link> example.
cs: Tento příklad vychází z příkladu <link xref="toolbar.c">Toolbar</link>.

note: (itstool) path: section/code
en: #include &lt;gtk/gtk.h&gt;
    
    static gboolean 
    undo_tooltip_callback (GtkStatusIcon *status_icon,
                           gint           x,
                           gint           y,
                           gboolean       keyboard_mode,
                           GtkTooltip    *tooltip,
                           gpointer       user_data)
    {
      /* set the text for the tooltip */
      gtk_tooltip_set_text (tooltip, "Undo your last action");
       
      /* set an icon for the tooltip */
      gtk_tooltip_set_icon_from_stock(tooltip, "gtk-undo", GTK_ICON_SIZE_MENU);
    
      /* show the tooltip */
      return TRUE;
    }
    
    
    static void
    undo_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      g_print ("You clicked \"Undo\".\n");
    }
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *grid;
      GtkWidget *window;
      GtkWidget *toolbar;
    
      GtkToolItem *new_button;
      GtkToolItem *open_button;
      GtkToolItem *undo_button;
    
      GtkStyleContext *style_context;
    
      GSimpleAction *undo_action;
    
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Toolbar with Tooltips Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 400, 200);
    
      /* Here we begin to create the toolbar */
      toolbar = gtk_toolbar_new ();
    
      /* Set the toolbar to be the primary toolbar of the application */
      style_context = gtk_widget_get_style_context (toolbar);
      gtk_style_context_add_class (style_context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
    
      /* Create a button for the "new" action, with a stock image */
      new_button = gtk_tool_button_new_from_stock (GTK_STOCK_NEW);
      gtk_tool_item_set_is_important (new_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), new_button, 0);
      gtk_widget_show (GTK_WIDGET (new_button));
    
      /* Set the action name for the "new" action. We use "app.new" to
       * indicate that the action controls the application.
       */
      gtk_actionable_set_action_name (GTK_ACTIONABLE (new_button), "app.new");
    
      /*******************************
       * Tooltip for the New ToolItem:
       * a tooltip with text
       *******************************/
       gtk_tool_item_set_tooltip_text (new_button, "Create a new file");  
    
      /* "Open" */
      open_button = gtk_tool_button_new_from_stock (GTK_STOCK_OPEN);
      gtk_tool_item_set_is_important (open_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), open_button, 1);
      gtk_widget_show (GTK_WIDGET (open_button));
      gtk_actionable_set_action_name (GTK_ACTIONABLE (open_button), "app.open");
    
      /*******************************
       * Tooltip for the Open ToolItem:
       * a tooltip using Pango markup 
       * language
       *******************************/
      gtk_tool_item_set_tooltip_text (open_button, "Open an &lt;i&gt;existing&lt;/i&gt; file");
    
      /* "Undo" */
      undo_button = gtk_tool_button_new_from_stock (GTK_STOCK_UNDO);
      gtk_tool_item_set_is_important (undo_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), undo_button, 2);
      gtk_widget_show (GTK_WIDGET (undo_button));
    
      /* In this case, we use "win.undo" to indicate that
       * the action controls only the window
       */
      gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "win.undo");
    
      /*******************************
       * Tooltip for the Undo ToolItem:
       * a tooltip with an image
       *******************************/
      gtk_widget_set_has_tooltip (GTK_WIDGET (undo_button), TRUE);
    
      // Next, we connect the query_tooltip signal
      g_signal_connect (undo_button, "query-tooltip", G_CALLBACK (undo_tooltip_callback), NULL);
    
      gtk_widget_set_hexpand (toolbar, TRUE);
      gtk_widget_show (toolbar);
    
      grid = gtk_grid_new ();
      gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 1, 1);
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
      gtk_widget_show (GTK_WIDGET (grid));
    
      /* Use the action names to create the actions that control the window, and
       * connect them to the appropriate callbackfunctions.
       */
      undo_action = g_simple_action_new ("undo", NULL);
      g_signal_connect (undo_action, "activate", G_CALLBACK (undo_callback),
                        GTK_WINDOW (window));
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (undo_action));
    
      gtk_widget_show (window);
    }
    
    
    /* Callback function for the new action */
    static void
    new_callback (GSimpleAction *simple,
                  GVariant      *parameter,
                  gpointer       user_data)
    {
      g_print ("You clicked \"New\".\n");
    }
    
    
    /* Callback function for the open action */
    static void
    open_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      g_print ("You clicked \"Open\".\n");
    }
    
    
    /* In this function, we create the actions in which control the window, and
     * connect their signals to the appropriate callback function.
     */
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      GSimpleAction *new_action;
      GSimpleAction *open_action;
    
      new_action = g_simple_action_new ("new", NULL);
      g_signal_connect (new_action, "activate", G_CALLBACK (new_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (new_action));
    
      open_action = g_simple_action_new ("open", NULL);
      g_signal_connect (open_action, "activate", G_CALLBACK (open_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (open_action));
    }
    
    
    
    /* Startup function for the application */
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }
cs: #include &lt;gtk/gtk.h&gt;
    
    static gboolean 
    undo_tooltip_callback (GtkStatusIcon *status_icon,
                           gint           x,
                           gint           y,
                           gboolean       keyboard_mode,
                           GtkTooltip    *tooltip,
                           gpointer       user_data)
    {
      /* Nastaví text pro vysvětlivku */
      gtk_tooltip_set_text (tooltip, "Undo your last action");
       
      /* Nastaví ikonu pro vysvětlivku */
      gtk_tooltip_set_icon_from_stock(tooltip, "gtk-undo", GTK_ICON_SIZE_MENU);
    
      /* Zobrazí vysvětlivku */
      return TRUE;
    }
    
    
    static void
    undo_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      g_print ("You clicked \"Undo\".\n");
    }
    
    
    static void
    activate (GtkApplication *app,
              gpointer        user_data)
    {
      GtkWidget *grid;
      GtkWidget *window;
      GtkWidget *toolbar;
    
      GtkToolItem *new_button;
      GtkToolItem *open_button;
      GtkToolItem *undo_button;
    
      GtkStyleContext *style_context;
    
      GSimpleAction *undo_action;
    
      window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (window), "Toolbar with Tooltips Example");
      gtk_window_set_default_size (GTK_WINDOW (window), 400, 200);
    
      /* Zde začínáme vytvářet nástrojovou lištu */
      toolbar = gtk_toolbar_new ();
    
      /* Nataví nástrojovou lištu jako hlavní pro aplikaci */
      style_context = gtk_widget_get_style_context (toolbar);
      gtk_style_context_add_class (style_context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
    
      /* Vytvoří tlačítko pro akci "new", se standardní ikonou */
      new_button = gtk_tool_button_new_from_stock (GTK_STOCK_NEW);
      gtk_tool_item_set_is_important (new_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), new_button, 0);
      gtk_widget_show (GTK_WIDGET (new_button));
    
      /* Nastaví název akce na "new". Použije se "app.new", aby bylo
       * poznat, že akce ovládá aplikaci
       */
      gtk_actionable_set_action_name (GTK_ACTIONABLE (new_button), "app.new");
    
      /*********************************
       * Vysvětlivka pro položku "New":
       * vysvětlivka s textem
       *********************************/
       gtk_tool_item_set_tooltip_text (new_button, "Create a new file");  
    
      /* Položka "Open" */
      open_button = gtk_tool_button_new_from_stock (GTK_STOCK_OPEN);
      gtk_tool_item_set_is_important (open_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), open_button, 1);
      gtk_widget_show (GTK_WIDGET (open_button));
      gtk_actionable_set_action_name (GTK_ACTIONABLE (open_button), "app.open");
    
      /**********************************
       * Vysvětlivka pro položku "Open":
       * vysvětlivka používající
       * značkovací jazyk Pango
       **********************************/
      gtk_tool_item_set_tooltip_text (open_button, "Open an &lt;i&gt;existing&lt;/i&gt; file");
    
      /* Položka "Undo" */
      undo_button = gtk_tool_button_new_from_stock (GTK_STOCK_UNDO);
      gtk_tool_item_set_is_important (undo_button, TRUE);
      gtk_toolbar_insert (GTK_TOOLBAR (toolbar), undo_button, 2);
      gtk_widget_show (GTK_WIDGET (undo_button));
    
      /* V tomto případě se použije "win.undo", aby bylo poznat,
       * že akce ovládá okno
       */
      gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "win.undo");
    
      /**********************************
       * Vysvětlivka pro položku "Undo":
       * vysvětlivka s obrázkem
       **********************************/
      gtk_widget_set_has_tooltip (GTK_WIDGET (undo_button), TRUE);
    
      // Následně se připojí signál query_tooltip
      g_signal_connect (undo_button, "query-tooltip", G_CALLBACK (undo_tooltip_callback), NULL);
    
      gtk_widget_set_hexpand (toolbar, TRUE);
      gtk_widget_show (toolbar);
    
      grid = gtk_grid_new ();
      gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 1, 1);
      gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (grid));
      gtk_widget_show (GTK_WIDGET (grid));
    
      /* Použije název akce k vytvoření akcí, které ovládají okno a
       * napojí je na příslušné funkce zpětného volání
       */
      undo_action = g_simple_action_new ("undo", NULL);
      g_signal_connect (undo_action, "activate", G_CALLBACK (undo_callback),
                        GTK_WINDOW (window));
      g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (undo_action));
    
      gtk_widget_show (window);
    }
    
    
    /* Funkce zpětného volání pro akci "new" */
    static void
    new_callback (GSimpleAction *simple,
                  GVariant      *parameter,
                  gpointer       user_data)
    {
      g_print ("You clicked \"New\".\n");
    }
    
    
    /* Funkce zpětného volání pro akci "open" */
    static void
    open_callback (GSimpleAction *simple,
                   GVariant      *parameter,
                   gpointer       user_data)
    {
      g_print ("You clicked \"Open\".\n");
    }
    
    
    /* V této funkci se vytvoří akce, které ovládají okno a napojí
     * se jejich signály na příslušné funkce zpětného volání
     */
    static void
    startup (GApplication *app,
             gpointer      user_data)
    {
      GSimpleAction *new_action;
      GSimpleAction *open_action;
    
      new_action = g_simple_action_new ("new", NULL);
      g_signal_connect (new_action, "activate", G_CALLBACK (new_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (new_action));
    
      open_action = g_simple_action_new ("open", NULL);
      g_signal_connect (open_action, "activate", G_CALLBACK (open_callback), app);
      g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (open_action));
    }
    
    
    
    /* Spouštěcí funkce pro aplikaci */
    int
    main (int argc, char **argv)
    {
      GtkApplication *app;
      int status;
    
      app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
    
      return status;
    }

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/gtk3/stable/gtk3-Stock-Items.html">Stock Items</link>
cs: <link href="http://developer.gnome.org/gtk3/stable/gtk3-Stock-Items.html">Standardní položky</link>

note: (itstool) path: note/p
en: This example builds on the <link xref="toolbar.js">Toolbar</link> example.
cs: Tento příklad navazuje na příklad <link xref="toolbar.js">Toolbar</link>.

note: (itstool) path: section/code
en: //!/usr/bin/gjs
    
    imports.gi.versions.Gdk = '3.0';
    imports.gi.versions.Gtk = '3.0';
    
    const Gdk = imports.gi.Gdk;
    const GLib = imports.gi.GLib;
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk; 
    
    class TooltipExample {
        // Create the application 
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstooltip'
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this.window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this.window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Toolbar with Tooltips Example",
                default_width: 400,
                default_height: 200,
                border_width: 10
            });
    
            this.grid = new Gtk.Grid();
    
            this.toolbar = this._createToolbar();
            this.toolbar.set_hexpand(true);
            this.toolbar.show();
    
            this.grid.attach(this.toolbar, 0, 0, 1, 1);
    
            this.window.add(this.grid);
    
            this._newAction = new Gio.SimpleAction({ name: "new" });
            this._newAction.connect("activate", this._newCallback.bind(this));
            this.window.add_action(this._newAction);
    
            this._openAction = new Gio.SimpleAction({ name: "open" });
            this._openAction.connect("activate", this._openCallback.bind(this));
            this.window.add_action(this._openAction);
    
            this._undoAction = new Gio.SimpleAction({ name: "undo" });
            this._undoAction.connect("activate", this._undoCallback.bind(this));
            this.window.add_action(this._undoAction);
    
            this._fullScreenAction = new Gio.SimpleAction({ name: "fullscreenToggle" });
            this._fullScreenAction.connect("activate",
                                           this._fullScreenCallback.bind(this));
            this.window.add_action(this._fullScreenAction);
    
            this.window.show_all();
        }
    
        _createToolbar() {
            this.toolbar = new Gtk.Toolbar();
            this.toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR);
    
            // button for the "new" action
            this.newButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_NEW);
            // with a tooltip with a given text        
            this.newButton.set_tooltip_text("Create a new file");
            this.newButton.set_is_important(true);
            this.toolbar.insert(this.newButton, 0);
            this.newButton.show();
            this.newButton.set_action_name("win.new");
    
            // button for the "open" action
            this.openButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_OPEN);
            // with a tooltip with a given text in the Pango markup language        
            this.openButton.set_tooltip_markup("Open an &lt;i&gt;existing&lt;/i&gt; file");
            this.openButton.set_is_important(true);
            this.toolbar.insert(this.openButton, 1);
            this.openButton.show();
            this.openButton.set_action_name("win.open");
    
            // button for the "undo" action
            this.undoButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_UNDO);
            // with a tooltip with an image
            // set true the property "has-tooltip"        
            this.undoButton.set_property("has-tooltip", true);
            // connect to the callback function that for the tooltip
            // with the signal "query-tooltip"
            this.undoButton.connect("query-tooltip", this._undoTooltipCallback.bind(this));
            this.undoButton.set_is_important(true);
            this.toolbar.insert(this.undoButton, 2);
            this.undoButton.show();
            this.undoButton.set_action_name("win.undo");
    
            // button for the "fullscreen/leave fullscreen" action
            this.fullscreenButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_FULLSCREEN);
            this.fullscreenButton.set_is_important(true);
            this.toolbar.insert(this.fullscreenButton, 3);
            this.fullscreenButton.set_action_name("win.fullscreenToggle");
    
            return this.toolbar;
        }
    
        _newCallback(action, parameter) {
            print("You clicked \"New\".");
        }
    
        _openCallback(action, parameter) {
            print("You clicked \"Open\".");
        }
    
        // the callback function for the tooltip of the "undo" button
        _undoTooltipCallback(widget, x, y, keyboard_mode, tooltip) {
            // set the text for the tooltip
            tooltip.set_text("Undo your last action");
            // set an icon for the tooltip
            tooltip.set_icon_from_stock(Gtk.STOCK_UNDO, Gtk.IconSize.MENU);
            // show the tooltip
            return true;
        }
    
        _undoCallback(action, parameter) {
            print("You clicked \"Undo\".");
        }
    
        _fullScreenCallback() {
            if ((this.window.get_window().get_state() &amp; Gdk.WindowState.FULLSCREEN) != 0 ){
                this.fullscreenButton.set_stock_id(Gtk.STOCK_FULLSCREEN);
                this.fullscreenButton.set_tooltip_text("Make your window fullscreen");
                this.window.unfullscreen();
            } else {
                this.fullscreenButton.set_stock_id(Gtk.STOCK_LEAVE_FULLSCREEN);
                this.fullscreenButton.set_tooltip_text("Leave fullscreen");
                this.window.fullscreen();
            }
        }
    };
    
    // Run the application
    let app = new TooltipExample ();
    app.application.run (ARGV);
cs: //!/usr/bin/gjs
    
    imports.gi.versions.Gdk = '3.0';
    imports.gi.versions.Gtk = '3.0';
    
    const Gdk = imports.gi.Gdk;
    const GLib = imports.gi.GLib;
    const Gio = imports.gi.Gio;
    const Gtk = imports.gi.Gtk; 
    
    class TooltipExample {
        // Vytvoří aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstooltip'
            });
    
            // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this.window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
    
            // Vytvoří okno aplikace
            this.window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                title: "Toolbar with Tooltips Example",
                default_width: 400,
                default_height: 200,
                border_width: 10
            });
    
            this.grid = new Gtk.Grid();
    
            this.toolbar = this._createToolbar();
            this.toolbar.set_hexpand(true);
            this.toolbar.show();
    
            this.grid.attach(this.toolbar, 0, 0, 1, 1);
    
            this.window.add(this.grid);
    
            this._newAction = new Gio.SimpleAction({ name: "new" });
            this._newAction.connect("activate", this._newCallback.bind(this));
            this.window.add_action(this._newAction);
    
            this._openAction = new Gio.SimpleAction({ name: "open" });
            this._openAction.connect("activate", this._openCallback.bind(this));
            this.window.add_action(this._openAction);
    
            this._undoAction = new Gio.SimpleAction({ name: "undo" });
            this._undoAction.connect("activate", this._undoCallback.bind(this));
            this.window.add_action(this._undoAction);
    
            this._fullScreenAction = new Gio.SimpleAction({ name: "fullscreenToggle" });
            this._fullScreenAction.connect("activate",
                                           this._fullScreenCallback.bind(this));
            this.window.add_action(this._fullScreenAction);
    
            this.window.show_all();
        }
    
        _createToolbar() {
            this.toolbar = new Gtk.Toolbar();
            this.toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR);
    
            // Tlačítko pro akci „new“
            this.newButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_NEW);
            // s vysvětlivkou se zadaným textem
            this.newButton.set_tooltip_text("Create a new file");
            this.newButton.set_is_important(true);
            this.toolbar.insert(this.newButton, 0);
            this.newButton.show();
            this.newButton.set_action_name("win.new");
    
            // Tlačítko pro akci „open“
            this.openButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_OPEN);
            // s vysvětlivkou se zadaným textem ve značkovacím jazyce Pango
            this.openButton.set_tooltip_markup("Open an &lt;i&gt;existing&lt;/i&gt; file");
            this.openButton.set_is_important(true);
            this.toolbar.insert(this.openButton, 1);
            this.openButton.show();
            this.openButton.set_action_name("win.open");
    
            // Tlačítko pro akci „undo“
            this.undoButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_UNDO);
            // s vysvětlivkou s obrázkem
            // Nataví vlastnost „has-tooltip“ na true
            this.undoButton.set_property("has-tooltip", true);
            // Napojí funkci zpětného volání pro vysvětlivku
            // se signálem „query-tooltip“
            this.undoButton.connect("query-tooltip", this._undoTooltipCallback.bind(this));
            this.undoButton.set_is_important(true);
            this.toolbar.insert(this.undoButton, 2);
            this.undoButton.show();
            this.undoButton.set_action_name("win.undo");
    
            // Tlačítko pro akci „fullscreen/leave fullscreen“
            this.fullscreenButton = Gtk.ToolButton.new_from_stock(Gtk.STOCK_FULLSCREEN);
            this.fullscreenButton.set_is_important(true);
            this.toolbar.insert(this.fullscreenButton, 3);
            this.fullscreenButton.set_action_name("win.fullscreenToggle");
    
            return this.toolbar;
        }
    
        _newCallback(action, parameter) {
            print("You clicked \"New\".");
        }
    
        _openCallback(action, parameter) {
            print("You clicked \"Open\".");
        }
    
        // Funkce zpětného volání pro vysvětlivku tlačítka „undo“
        _undoTooltipCallback(widget, x, y, keyboard_mode, tooltip) {
            // Nastaví text pro vysvětlivku
            tooltip.set_text("Undo your last action");
            // Nastaví ikonu pro vysvětlivku
            tooltip.set_icon_from_stock(Gtk.STOCK_UNDO, Gtk.IconSize.MENU);
            // Zobrazí vysvětlivku
            return true;
        }
    
        _undoCallback(action, parameter) {
            print("You clicked \"Undo\".");
        }
    
        _fullScreenCallback() {
            if ((this.window.get_window().get_state() &amp; Gdk.WindowState.FULLSCREEN) != 0 ){
                this.fullscreenButton.set_stock_id(Gtk.STOCK_FULLSCREEN);
                this.fullscreenButton.set_tooltip_text("Make your window fullscreen");
                this.window.unfullscreen();
            } else {
                this.fullscreenButton.set_stock_id(Gtk.STOCK_LEAVE_FULLSCREEN);
                this.fullscreenButton.set_tooltip_text("Leave fullscreen");
                this.window.fullscreen();
            }
        }
    };
    
    // Spustí aplikaci
    let app = new TooltipExample ();
    app.application.run (ARGV);

note: (itstool) path: note/p
en: This example builds on the <link xref="toolbar.py">Toolbar</link> example.
cs: Tento příklad vychází z příkladu <link xref="toolbar.py">Toolbar</link>.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Gdk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(
                self, title="Toolbar with Tooltips Example", application=app)
            self.set_default_size(400, 200)
    
            grid = Gtk.Grid()
    
            toolbar = self.create_toolbar()
            toolbar.set_hexpand(True)
            toolbar.show()
    
            grid.attach(toolbar, 0, 0, 1, 1)
    
            self.add(grid)
    
            undo_action = Gio.SimpleAction.new("undo", None)
            undo_action.connect("activate", self.undo_callback)
            self.add_action(undo_action)
    
            fullscreen_action = Gio.SimpleAction.new("fullscreen", None)
            fullscreen_action.connect("activate", self.fullscreen_callback)
            self.add_action(fullscreen_action)
    
        def create_toolbar(self):
            toolbar = Gtk.Toolbar()
            toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
    
            # button for the "new" action
            new_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_NEW)
            # with a tooltip with a given text
            new_button.set_tooltip_text("Create a new file")
            new_button.set_is_important(True)
            toolbar.insert(new_button, 0)
            new_button.show()
            new_button.set_action_name("app.new")
    
            # button for the "open" action
            open_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_OPEN)
            # with a tooltip with a given text in the Pango markup language
            open_button.set_tooltip_markup("Open an &lt;i&gt;existing&lt;/i&gt; file")
            open_button.set_is_important(True)
            toolbar.insert(open_button, 1)
            open_button.show()
            open_button.set_action_name("app.open")
    
            # button for the "undo" action
            undo_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_UNDO)
            # with a tooltip with an image
            # set True the property "has-tooltip"
            undo_button.set_property("has-tooltip", True)
            # connect to the callback function that for the tooltip
            # with the signal "query-tooltip"
            undo_button.connect("query-tooltip", self.undo_tooltip_callback)
            undo_button.set_is_important(True)
            toolbar.insert(undo_button, 2)
            undo_button.show()
            undo_button.set_action_name("win.undo")
    
            # button for the "fullscreen/leave fullscreen" action
            self.fullscreen_button = Gtk.ToolButton.new_from_stock(
                Gtk.STOCK_FULLSCREEN)
            self.fullscreen_button.set_is_important(True)
            toolbar.insert(self.fullscreen_button, 3)
            self.fullscreen_button.set_action_name("win.fullscreen")
    
            return toolbar
    
        # the callback function for the tooltip of the "undo" button
        def undo_tooltip_callback(self, widget, x, y, keyboard_mode, tooltip):
            # set the text for the tooltip
            tooltip.set_text("Undo your last action")
            # set an icon for the tooltip
            tooltip.set_icon_from_stock("gtk-undo", Gtk.IconSize.MENU)
            # show the tooltip
            return True
    
        def undo_callback(self, action, parameter):
            print("You clicked \"Undo\".")
    
        def fullscreen_callback(self, action, parameter):
            is_fullscreen = self.get_window().get_state(
            ) &amp; Gdk.WindowState.FULLSCREEN != 0
            if not is_fullscreen:
                self.fullscreen_button.set_stock_id(Gtk.STOCK_LEAVE_FULLSCREEN)
                self.fullscreen()
            else:
                self.fullscreen_button.set_stock_id(Gtk.STOCK_FULLSCREEN)
                self.unfullscreen()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            new_action = Gio.SimpleAction.new("new", None)
            new_action.connect("activate", self.new_callback)
            app.add_action(new_action)
    
            open_action = Gio.SimpleAction.new("open", None)
            open_action.connect("activate", self.open_callback)
            app.add_action(open_action)
    
        def new_callback(self, action, parameter):
            print("You clicked \"New\".")
    
        def open_callback(self, action, parameter):
            print("You clicked \"Open\".")
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Gdk
    from gi.repository import Gio
    import sys
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(
                self, title="Toolbar with Tooltips Example", application=app)
            self.set_default_size(400, 200)
    
            grid = Gtk.Grid()
    
            toolbar = self.create_toolbar()
            toolbar.set_hexpand(True)
            toolbar.show()
    
            grid.attach(toolbar, 0, 0, 1, 1)
    
            self.add(grid)
    
            undo_action = Gio.SimpleAction.new("undo", None)
            undo_action.connect("activate", self.undo_callback)
            self.add_action(undo_action)
    
            fullscreen_action = Gio.SimpleAction.new("fullscreen", None)
            fullscreen_action.connect("activate", self.fullscreen_callback)
            self.add_action(fullscreen_action)
    
        def create_toolbar(self):
            toolbar = Gtk.Toolbar()
            toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
    
            # Tlačítko pro akci "new"
            new_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_NEW)
            # S vysvětlivkou se zadaným textem
            new_button.set_tooltip_text("Create a new file")
            new_button.set_is_important(True)
            toolbar.insert(new_button, 0)
            new_button.show()
            new_button.set_action_name("app.new")
    
            # Tlačítko pro akci "open"
            open_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_OPEN)
            # S vysvětlivkou se zadaným textem s použitím značkovacího jazyka Pango
            open_button.set_tooltip_markup("Open an &lt;i&gt;existing&lt;/i&gt; file")
            open_button.set_is_important(True)
            toolbar.insert(open_button, 1)
            open_button.show()
            open_button.set_action_name("app.open")
    
            # Tlačítko pro akci "undo"
            undo_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_UNDO)
            # S vysvětlivkou s obrázkem
            # Nastaví vlastnost "has-tooltip" na True
            undo_button.set_property("has-tooltip", True)
            # Napojí funkci zpětného volání na signál "query-tooltip"
            # od vysvětlivky
            undo_button.connect("query-tooltip", self.undo_tooltip_callback)
            undo_button.set_is_important(True)
            toolbar.insert(undo_button, 2)
            undo_button.show()
            undo_button.set_action_name("win.undo")
    
            # Tlačítko pro akci "fullscreen/leave fullscreen"
            self.fullscreen_button = Gtk.ToolButton.new_from_stock(
                Gtk.STOCK_FULLSCREEN)
            self.fullscreen_button.set_is_important(True)
            toolbar.insert(self.fullscreen_button, 3)
            self.fullscreen_button.set_action_name("win.fullscreen")
    
            return toolbar
    
        # Funkce zpětného volání pro vysvětlivku tlačítka "undo"
        def undo_tooltip_callback(self, widget, x, y, keyboard_mode, tooltip):
            # Nastaví text pro vysvětlivku
            tooltip.set_text("Undo your last action")
            # Nastaví ikonu pro vysvětlivku
            tooltip.set_icon_from_stock("gtk-undo", Gtk.IconSize.MENU)
            # Zobrazí vysvětlivku
            return True
    
        def undo_callback(self, action, parameter):
            print("You clicked \"Undo\".")
    
        def fullscreen_callback(self, action, parameter):
            is_fullscreen = self.get_window().get_state(
            ) &amp; Gdk.WindowState.FULLSCREEN != 0
            if not is_fullscreen:
                self.fullscreen_button.set_stock_id(Gtk.STOCK_LEAVE_FULLSCREEN)
                self.fullscreen()
            else:
                self.fullscreen_button.set_stock_id(Gtk.STOCK_FULLSCREEN)
                self.unfullscreen()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
            new_action = Gio.SimpleAction.new("new", None)
            new_action.connect("activate", self.new_callback)
            app.add_action(new_action)
    
            open_action = Gio.SimpleAction.new("open", None)
            open_action.connect("activate", self.open_callback)
            app.add_action(open_action)
    
        def new_callback(self, action, parameter):
            print("You clicked \"New\".")
    
        def open_callback(self, action, parameter):
            print("You clicked \"Open\".")
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Tooltip widget
cs: Užitečné metody pro widget Tooltip

note: (itstool) path: section/p
en: <code>set_tooltip_text(text)</code> and <code>set_tooltip_markup(text)</code> can be used to add a tooltip of plain text (or text in the Pango Markup Language) to a widget.
cs: <code>set_tooltip_text(text)</code> a <code>set_tooltip_markup(text)</code> můžete použít k přidání vysvětlivky v podobě prostého textu (nebo textu se značkovacím jazykem Pango) k widgetu.

note: (itstool) path: section/p
en: For more complex tooltips, for instance for a tooltip with an image:
cs: Pro složitější vysvětlivky, například pro vysvětlivky s obrázky:

note: (itstool) path: item/p
en: Set the <code>"has-tooltip"</code> property of the widget to <code>True</code>; this will make GTK+ monitor the widget for motion and related events which are needed to determine when and where to show a tooltip.
cs: Nastavte vlastnost <code>"has-tooltip"</code> widgetu na <code>True</code>. To přiměje GTK+ sledovat widget ohledně pohybu myši a dalších událostí, které jsou zapotřebí k určení, kdy a kde zobrazit vysvětlivku.

note: (itstool) path: item/p
en: Connect to the <code>"query-tooltip"</code> signal. This signal will be emitted when a tooltip is supposed to be shown. One of the arguments passed to the signal handler is a GtkTooltip object. This is the object that we are about to display as a tooltip, and can be manipulated in your callback using functions like <code>set_icon()</code>. There are functions for setting the tooltip's markup (<code>set_markup(text)</code>), setting an image from a stock icon (<code>set_icon_from_stock(stock_id, size)</code>), or even putting in a custom widget (<code>set_custom(widget)</code>).
cs: Napojte signál <code>"query-tooltip"</code>. Tento signál bude vyslán, když by měla být vysvětlivka zobrazena. Jedním z argumentů předaných do obsluhy signálu je objekt <code>GtkTooltip</code>. Jedná se o objekt, který bude zobrazen jako vysvětlivka a může být v našem zpětném volání upravován pomocí funkcí, jako je <code>set_icon()</code>. Existují funkce pro nastavení textu se značkovacím jazykem (<code>set_markup(text)</code>), pro nastavení obrázku ze standardní ikony (<code>set_icon_from_stock(standardní_id, velikost)</code>) nebo i pro vložení vlastního widgetu (<code>set_custom(widget)</code>).

note: (itstool) path: item/p
en: Return <code>True</code> from your query-tooltip handler. This causes the tooltip to be show. If you return <code>False</code>, it will not be shown.
cs: Ze své obsluhy signálu <code>"query-tooltip"</code> vraťte <code>True</code>. Způsobí to zobrazení vysvětlivky. Když vrátíte <code>False</code>, tak se nezobrazí.

note: (itstool) path: section/p
en: In the probably rare case where you want to have even more control over the tooltip that is about to be shown, you can set your own GtkWindow which will be used as tooltip window. This works as follows:
cs: V pravděpodobně zřídkavějších případech, kdy budete chtít větší kontrolu nad vysvětlivkou, která se má zobrazit, můžete nastavit své vlastní <code>GtkWidow</code>, které bude použito jako okno vysvětlivky. Funguje to následovně:

note: (itstool) path: item/p
en: Set <code>"has-tooltip"</code> and connect to <code>"query-tooltip"</code> as before.
cs: Nastavte <code>"has-tooltip"</code> a napojte ke <code>"query-tooltip"</code> stejně jako dříve.

note: (itstool) path: item/p
en: Use <code>set_tooltip_window()</code> on the widget to set a GtkWindow created by you as tooltip window.
cs: Použijte u widgetu funkci <code>set_tooltip_window()</code> k nastavení <code>GtkWindow</code>, které jste vytvořili, jako okna vysvětlivky.

note: (itstool) path: item/p
en: In the <code>"query-tooltip"</code> callback you can access your window using <code>get_tooltip_window()</code> and manipulate as you wish. The semantics of the return value are exactly as before, return <code>True</code> to show the window, <code>False</code> to not show it.
cs: Ve zpětném volání pro signál <code>"query-tooltip"</code> máte přístup ke svému oknu pomocí <code>get_tooltip_window()</code> a upravte si jej podle svých potřeb. Sémantika vracené hodnoty je úplně stejná jako v předchozím – <code>True</code> okno zobrazí, <code>False</code> jej nezobrazí.

note: (itstool) path: note/p
en: This example builds on the <link xref="toolbar.vala">Toolbar</link> example.
cs: Tento příklad vychází z příkladu <link xref="toolbar.vala">Toolbar</link>.

note: (itstool) path: section/code
en: /* This is the Window */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* Instance variables belonging to the window */
    	Gtk.Toolbar toolbar;
    	Gtk.ToolButton new_button;
    	Gtk.ToolButton open_button;
    	Gtk.ToolButton undo_button;
    	Gtk.ToolButton fullscreen_button;
    	Gtk.ToolButton leave_fullscreen_button;
    
    	/* Constructor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Toolbar with Tooltips Example");
    
    		this.set_default_size (400, 200);
    		var grid = new Gtk.Grid ();
    		this.add (grid);
    		grid.show ();
    
    		create_toolbar ();
    		toolbar.set_hexpand (true);
    		grid.attach (toolbar, 0, 0, 1, 1);
    		toolbar.show ();
    
    		/* create the "undo" window action action */
    		var undo_action = new SimpleAction ("undo", null);
    		undo_action.activate.connect (undo_callback);
    		this.add_action (undo_action);
    
    		/* create the "fullscreen" window action */
    		var fullscreen_action = new SimpleAction ("fullscreen", null);
    		fullscreen_action.activate.connect (fullscreen_callback);
    		this.add_action (fullscreen_action);
    	}
    
    	/* Callback for query_tooltip signal */
    	bool undo_tooltip_callback (int x, int y, bool keyboard_tooltip, Gtk.Tooltip tooltip) {
    
    		/* set the text for the tooltip */
            	tooltip.set_text ("Undo your last action");
    		
    		/* set an icon for the tooltip */
    		tooltip.set_icon_from_stock("gtk-undo", Gtk.IconSize.MENU);
    
            	/* show the tooltip */
            	return true;
    	}
    
    	/* This function creates the toolbar, its  ToolButtons,
    	 * and assigns the actions names to the ToolButtons.*/
    	void create_toolbar () {
    		toolbar = new Gtk.Toolbar ();
    		toolbar.get_style_context ().add_class (Gtk.STYLE_CLASS_PRIMARY_TOOLBAR);
    
    		new_button = new Gtk.ToolButton.from_stock (Gtk.Stock.NEW);
    
    		/* tooltip with text */
    		new_button.set_tooltip_text ("Create a new file");
    
    		new_button.is_important = true; //decides whether to show the label
    		toolbar.add (new_button);
    		new_button.show ();
    		new_button.action_name = "app.new";
    
    		open_button = new Gtk.ToolButton.from_stock (Gtk.Stock.OPEN);
    
    		/* a tooltip using Pango markup language */
    		open_button.set_tooltip_markup ("Open an &lt;i&gt;existing&lt;/i&gt; file");
    
    		open_button.is_important = true;
    		toolbar.add (open_button);
    		open_button.show ();
    		open_button.action_name = "app.open";
    
    		undo_button = new Gtk.ToolButton.from_stock (Gtk.Stock.UNDO);
    	
    		/* For a tooltip to have an image, first we must set_has_tooltip to be 'true' */	
    		(undo_button as Gtk.Widget).set_has_tooltip (true);
    
    		/* Connect the query_tooltip signal to the callback */
    		undo_button.query_tooltip.connect (undo_tooltip_callback);
    	
    		undo_button.is_important = true;
    		toolbar.add (undo_button);
    		undo_button.show ();
    		undo_button.action_name = "win.undo";
    
    		fullscreen_button = new Gtk.ToolButton.from_stock (Gtk.Stock.FULLSCREEN);
    		fullscreen_button.is_important = true;
    		toolbar.add (fullscreen_button);
    		fullscreen_button.show ();
    		fullscreen_button.action_name = "win.fullscreen";
    
    		leave_fullscreen_button = new Gtk.ToolButton.from_stock (Gtk.Stock.LEAVE_FULLSCREEN)
    ;
    		leave_fullscreen_button.is_important = true;
    		toolbar.add (leave_fullscreen_button);
    
    		leave_fullscreen_button.action_name = "win.fullscreen";
    	}
    
    	void undo_callback (SimpleAction simple, Variant? parameter) {
    			print ("You clicked \"Undo\".\n");
    	}
    
    	void fullscreen_callback (SimpleAction simple, Variant? parameter) {
    		if ((this.get_window ().get_state () &amp; Gdk.WindowState.FULLSCREEN) != 0) {
    			this.unfullscreen ();
    			leave_fullscreen_button.hide ();
    			fullscreen_button.show ();
    		}
    		else {
    			this.fullscreen ();
    			fullscreen_button.hide ();
    			leave_fullscreen_button.show ();
    		}
    	}
    }
    
    /* This is the application */
    class MyApplication : Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    	protected override void startup () {
    		base.startup ();
    
    		/* Create the "new" action and add it to the app*/
    		var new_action = new SimpleAction ("new", null);
    		new_action.activate.connect (new_callback);
    		this.add_action (new_action);
    
    		/* Create the "open" action, and add it to the app */
    		var open_action = new SimpleAction ("open", null);
    		open_action.activate.connect (open_callback);
    		this.add_action (open_action);
    
    		/* You could also add the action to the app menu
    		 * if you wanted to.
    		 */
    		//var menu = new Menu ();
    		//menu.append ("New", "app.new");
    		//this.app_menu = menu;
    	}
    
    	void new_callback (SimpleAction action, Variant? parameter) {
    		print ("You clicked \"New\".\n");
    	}
    
    	void open_callback (SimpleAction action, Variant? parameter) {
    			print ("You clicked \"Open\".\n");
    	}
    }
    
    /* The main function creates the application and runs it. */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: /* Toto je okno */
    class MyWindow : Gtk.ApplicationWindow {
    
    	/* Instance proměnných náležejících k oknu */
    	Gtk.Toolbar toolbar;
    	Gtk.ToolButton new_button;
    	Gtk.ToolButton open_button;
    	Gtk.ToolButton undo_button;
    	Gtk.ToolButton fullscreen_button;
    	Gtk.ToolButton leave_fullscreen_button;
    
    	/* Konstruktor */
    	internal MyWindow (MyApplication app) {
    		Object (application: app, title: "Toolbar with Tooltips Example");
    
    		this.set_default_size (400, 200);
    		var grid = new Gtk.Grid ();
    		this.add (grid);
    		grid.show ();
    
    		create_toolbar ();
    		toolbar.set_hexpand (true);
    		grid.attach (toolbar, 0, 0, 1, 1);
    		toolbar.show ();
    
    		/* Vytvoří akci "undo" okna */
    		var undo_action = new SimpleAction ("undo", null);
    		undo_action.activate.connect (undo_callback);
    		this.add_action (undo_action);
    
    		/* Vytvoří akci "fullscreen" okna */
    		var fullscreen_action = new SimpleAction ("fullscreen", null);
    		fullscreen_action.activate.connect (fullscreen_callback);
    		this.add_action (fullscreen_action);
    	}
    
    	/* Zpětné volání pro signál query_tooltip */
    	bool undo_tooltip_callback (int x, int y, bool keyboard_tooltip, Gtk.Tooltip tooltip) {
    
    		/* Nastaví text pro vysvětlivku */
            	tooltip.set_text ("Undo your last action");
    		
    		/* Nastaví ikonu pro vysvětlivku */
    		tooltip.set_icon_from_stock("gtk-undo", Gtk.IconSize.MENU);
    
            	/* show the tooltip */
            	return true;
    	}
    
    	/* Tato funkce vytvoří nástrojovou lištu, její tlačítka
    	 * ToolButton a přiřadí jim názvy akcí.*/
    	void create_toolbar () {
    		toolbar = new Gtk.Toolbar ();
    		toolbar.get_style_context ().add_class (Gtk.STYLE_CLASS_PRIMARY_TOOLBAR);
    
    		new_button = new Gtk.ToolButton.from_stock (Gtk.Stock.NEW);
    
    		/* Vysvětlivka s textem */
    		new_button.set_tooltip_text ("Create a new file");
    
    		new_button.is_important = true; //decides whether to show the label
    		toolbar.add (new_button);
    		new_button.show ();
    		new_button.action_name = "app.new";
    
    		open_button = new Gtk.ToolButton.from_stock (Gtk.Stock.OPEN);
    
    		/* Vysvětlivka používající značkovací jazyk Pango */
    		open_button.set_tooltip_markup ("Open an &lt;i&gt;existing&lt;/i&gt; file");
    
    		open_button.is_important = true;
    		toolbar.add (open_button);
    		open_button.show ();
    		open_button.action_name = "app.open";
    
    		undo_button = new Gtk.ToolButton.from_stock (Gtk.Stock.UNDO);
    	
    		/* Pro vysvětlivku, která bude mít obrázek, nejprve musíme nastavit
    		 * set_has_tooltip na true */	
    		(undo_button as Gtk.Widget).set_has_tooltip (true);
    
    		/* Napojí signál query_tooltip na zpětné volání */
    		undo_button.query_tooltip.connect (undo_tooltip_callback);
    	
    		undo_button.is_important = true;
    		toolbar.add (undo_button);
    		undo_button.show ();
    		undo_button.action_name = "win.undo";
    
    		fullscreen_button = new Gtk.ToolButton.from_stock (Gtk.Stock.FULLSCREEN);
    		fullscreen_button.is_important = true;
    		toolbar.add (fullscreen_button);
    		fullscreen_button.show ();
    		fullscreen_button.action_name = "win.fullscreen";
    
    		leave_fullscreen_button = new Gtk.ToolButton.from_stock (Gtk.Stock.LEAVE_FULLSCREEN)
    ;
    		leave_fullscreen_button.is_important = true;
    		toolbar.add (leave_fullscreen_button);
    
    		leave_fullscreen_button.action_name = "win.fullscreen";
    	}
    
    	void undo_callback (SimpleAction simple, Variant? parameter) {
    			print ("You clicked \"Undo\".\n");
    	}
    
    	void fullscreen_callback (SimpleAction simple, Variant? parameter) {
    		if ((this.get_window ().get_state () &amp; Gdk.WindowState.FULLSCREEN) != 0) {
    			this.unfullscreen ();
    			leave_fullscreen_button.hide ();
    			fullscreen_button.show ();
    		}
    		else {
    			this.fullscreen ();
    			fullscreen_button.hide ();
    			leave_fullscreen_button.show ();
    		}
    	}
    }
    
    /* Toto je aplikace */
    class MyApplication : Gtk.Application {
    	protected override void activate () {
    		new MyWindow (this).show ();
    	}
    
    	protected override void startup () {
    		base.startup ();
    
    		/* Vytvoří akci "new" a přidá ji do aplikace */
    		var new_action = new SimpleAction ("new", null);
    		new_action.activate.connect (new_callback);
    		this.add_action (new_action);
    
    		/* Vytvoří akci "open" a přidá ji do aplikace */
    		var open_action = new SimpleAction ("open", null);
    		open_action.activate.connect (open_callback);
    		this.add_action (open_action);
    
    		/* Kdybychom chtěli, můžete přidat akci i do aplikační nabídky */
    		//var menu = new Menu ();
    		//menu.append ("New", "app.new");
    		//this.app_menu = menu;
    	}
    
    	void new_callback (SimpleAction action, Variant? parameter) {
    		print ("You clicked \"New\".\n");
    	}
    
    	void open_callback (SimpleAction action, Variant? parameter) {
    			print ("You clicked \"Open\".\n");
    	}
    }
    
    /* Funkce main vytvoří aplikaci a spustí ji */
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: item/p
en: <link href="https://developer.gnome.org/gtk3/3.4/gtk3-Stock-Items.html#GTK-STOCK-UNDO:CAPS">Stock Items</link>
cs: <link href="https://developer.gnome.org/gtk3/3.4/gtk3-Stock-Items.html#GTK-STOCK-UNDO:CAPS">Standardní položky</link>

[ctx: text]
note: (itstool) path: info/title
en: Simple Treeview with ListStore (Python)
cs: Jednoduchý Treeview s ListStore (Python)

note: (itstool) path: info/desc
en: A TreeView displaying a ListStore (more complex example)
cs: TreeView zobrazující ListStore (více komplexní příklad)

note: (itstool) path: page/title
en: More Complex Treeview with ListStore
cs: Více komplexní Treeview s ListStore

note: (itstool) path: page/p
en: This TreeView displays a simple ListStore with the selection "changed" signal connected.
cs: Tento TreeView zobrazuje jednoduchý ListStore s napojeným signálem <code>"changed"</code> (změna výběru).

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Pango
    import sys
    
    list_of_dvd = [["The Usual Suspects"],
                   ["Gilda"],
                   ["The Godfather"],
                   ["Pulp Fiction"],
                   ["Once Upon a Time in the West"],
                   ["Rear Window"]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="My DVDs", application=app)
            self.set_default_size(250, 100)
            self.set_border_width(10)
    
            # the data are stored in the model
            # create a liststore with one column
            self.listmodel = Gtk.ListStore(str)
            for i in range(len(list_of_dvd)):
                self.listmodel.append(list_of_dvd[i])
    
            # a treeview to see the data stored in the model
            view = Gtk.TreeView(model=self.listmodel)
    
            # cellrenderer for the first column
            cell = Gtk.CellRendererText()
            # the first column is created
            col = Gtk.TreeViewColumn("Title", cell, text=0)
            # and it is appended to the treeview
            view.append_column(col)
    
            # when a row of the treeview is selected, it emits a signal
            self.selection = view.get_selection()
            self.selection.connect("changed", self.on_changed)
    
            # the label we use to show the selection
            self.label = Gtk.Label()
            self.label.set_text("")
    
            # a button to add new titles, connected to a callback function
            self.button_add = Gtk.Button(label="Add")
            self.button_add.connect("clicked", self.add_cb)
    
            # an entry to enter titles
            self.entry = Gtk.Entry()
    
            # a button to remove titles, connected to a callback function
            self.button_remove = Gtk.Button(label="Remove")
            self.button_remove.connect("clicked", self.remove_cb)
    
            # a button to remove all titles, connected to a callback function
            self.button_remove_all = Gtk.Button(label="Remove All")
            self.button_remove_all.connect("clicked", self.remove_all_cb)
    
            # a grid to attach the widgets
            grid = Gtk.Grid()
            grid.attach(view, 0, 0, 4, 1)
            grid.attach(self.label, 0, 1, 4, 1)
            grid.attach(self.button_add, 0, 2, 1, 1)
            grid.attach_next_to(
                self.entry, self.button_add, Gtk.PositionType.RIGHT, 1, 1)
            grid.attach_next_to(
                self.button_remove, self.entry, Gtk.PositionType.RIGHT, 1, 1)
            grid.attach_next_to(
                self.button_remove_all, self.button_remove, Gtk.PositionType.RIGHT, 1, 1)
    
            # add the grid to the window
            self.add(grid)
    
        def on_changed(self, selection):
            # get the model and the iterator that points at the data in the model
            (model, iter) = selection.get_selected()
            # set the label to a new value depending on the selection, if there is
            # one
            if iter is not None:
                self.label.set_text("\n %s" % (model[iter][0]))
            else:
                self.label.set_text("")
            return True
    
        # callback function for the "Add" button
        def add_cb(self, button):
            # append to the model the title that is in the entry
            title = self.entry.get_text()
            self.listmodel.append([title])
            # and print a message in the terminal
            print("%s has been added" % (title))
    
        def remove_cb(self, button):
            # if there is still an entry in the model
            if len(self.listmodel) != 0:
                # get the selection
                (model, iter) = self.selection.get_selected()
                # if there is a selection, print a message in the terminal
                # and remove it from the model
                if iter is not None:
                    print("%s has been removed" % (model[iter][0]))
                    self.listmodel.remove(iter)
                # otherwise, ask the user to select something to remove
                else:
                    print("Select a title to remove")
            # else, if there are no entries in the model, print "Empty list"
            # in the terminal
            else:
                print("Empty list")
    
        def remove_all_cb(self, button):
            # if there is still an entry in the model
            if len(self.listmodel) != 0:
                # remove all the entries in the model
                for i in range(len(self.listmodel)):
                    iter = self.listmodel.get_iter(0)
                    self.listmodel.remove(iter)
            # print a message in the terminal alerting that the model is empty
            print("Empty list")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Pango
    import sys
    
    list_of_dvd = [["The Usual Suspects"],
                   ["Gilda"],
                   ["The Godfather"],
                   ["Pulp Fiction"],
                   ["Once Upon a Time in the West"],
                   ["Rear Window"]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="My DVDs", application=app)
            self.set_default_size(250, 100)
            self.set_border_width(10)
    
            # Datové úložiště v modelu
            # Vytvoří ListStore s jedním sloupcem
            self.listmodel = Gtk.ListStore(str)
            for i in range(len(list_of_dvd)):
                self.listmodel.append(list_of_dvd[i])
    
            # TreeView pro zobrazení dat uložených v modelu
            view = Gtk.TreeView(model=self.listmodel)
    
            # Vykreslovač buňky pro první sloupec
            cell = Gtk.CellRendererText()
            # Vytvoří první sloupec
            col = Gtk.TreeViewColumn("Title", cell, text=0)
            # a připojí jej do stromového zobrazení
            view.append_column(col)
    
            # Když je ve stromovém zobrazení vybrán řádek, vyšle signál
            self.selection = view.get_selection()
            self.selection.connect("changed", self.on_changed)
    
            # Popisek, který použijeme k zobrazení výběru
            self.label = Gtk.Label()
            self.label.set_text("")
    
            # Tlačítko pro přidání nového názvu, napojené na funkci zpětného volání
            self.button_add = Gtk.Button(label="Add")
            self.button_add.connect("clicked", self.add_cb)
    
            # Vstupní pole pro zadávání názvů
            self.entry = Gtk.Entry()
    
            # Tlačítko pro odstranění názvů, napojené na funkci zpětného volání
            self.button_remove = Gtk.Button(label="Remove")
            self.button_remove.connect("clicked", self.remove_cb)
    
            # Tlačítko pro odstranění všech názvů, napojené na funkci zpětného volání
            self.button_remove_all = Gtk.Button(label="Remove All")
            self.button_remove_all.connect("clicked", self.remove_all_cb)
    
            # Mřížka pro připojení widgetů
            grid = Gtk.Grid()
            grid.attach(view, 0, 0, 4, 1)
            grid.attach(self.label, 0, 1, 4, 1)
            grid.attach(self.button_add, 0, 2, 1, 1)
            grid.attach_next_to(
                self.entry, self.button_add, Gtk.PositionType.RIGHT, 1, 1)
            grid.attach_next_to(
                self.button_remove, self.entry, Gtk.PositionType.RIGHT, 1, 1)
            grid.attach_next_to(
                self.button_remove_all, self.button_remove, Gtk.PositionType.RIGHT, 1, 1)
    
            # Přidá mřížku do okna
            self.add(grid)
    
        def on_changed(self, selection):
            # Získá model a iterátor, který ukazuje na data v modelu
            (model, iter) = selection.get_selected()
            # Nastaví popisek na novou hodnotu podle výběru, pokud něco
            # vybráno je
            if iter is not None:
                self.label.set_text("\n %s" % (model[iter][0]))
            else:
                self.label.set_text("")
            return True
    
        # Funkce zpětného volání pro tlačítko "Add"
        def add_cb(self, button):
            # Připojí do modelu názevu, který je ve vstupním poli
            title = self.entry.get_text()
            self.listmodel.append([title])
            # A vypíše zprávu do terminálu
            print("%s has been added" % (title))
    
        def remove_cb(self, button):
            # Jestliže je v modelu ještě nějaký záznam
            if len(self.listmodel) != 0:
                # Získá výběr
                (model, iter) = self.selection.get_selected()
                # Jestliže je něco vybráno, vypíše zprávu do terminálu
                # a odstraní to z modelu
                if iter is not None:
                    print("%s has been removed" % (model[iter][0]))
                    self.listmodel.remove(iter)
                # Jinak vyzve uživatele, aby vybral, co chce odstranit
                else:
                    print("Select a title to remove")
            # Jinka, když v modelu není žádný záznam, vypíše "Empty list"
            # do terminálu
            else:
                print("Empty list")
    
        def remove_all_cb(self, button):
            # Jestliže je v modelu ještě nějaký záznam
            if len(self.listmodel) != 0:
                # Odstraní všechny záznamy v modelu
                for i in range(len(self.listmodel)):
                    iter = self.listmodel.get_iter(0)
                    self.listmodel.remove(iter)
            # Vypíše do terminálu zprávu, že model je teď prázdný
            print("Empty list")
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a TreeView widget
cs: Užitečné metody pro widget TreeView

note: (itstool) path: section/p
en: The TreeView widget is designed around a <em>Model/View/Controller</em> design: the <em>Model</em> stores the data; the <em>View</em> gets change notifications and displays the content of the model; the <em>Controller</em>, finally, changes the state of the model and notifies the view of these changes. For more information and for a list of useful methods for TreeModel see <link xref="model-view-controller.py"/>.
cs: Widget <code>TreeView</code> je navrže okolo návrhu <em>Model/Zobrazení/Ovládání</em>: <em>Model</em> uchovává data, <em>Zobrazení</em> získává upozornění a zobrazuje obsah modelu a konečně <em>Ovládání</em> změní stav modelu a upozorňuje zobrazení na tyto změny. Podrobnější informace a seznam užitečných metod pro stromové zobrazení najdete v <link xref="model-view-controller.py"/>.

note: (itstool) path: section/p
en: In line 36 the <code>"changed"</code> signal is connected to the callback function <code>on_changed()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 36 je signál <code>"changed"</code> napojen na funkci zpětného volání <code>on_changed()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

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

note: (itstool) path: info/desc
en: A TreeView displaying a TreeStore (more complex example, with CellRendererToggle)
cs: TreeView zobrazující TreeStore (více komplexní příklad s CellRendererToggle)

note: (itstool) path: page/title
en: More Complex TreeView with TreeStore
cs: Více komplexní TreeView s TreeStore

note: (itstool) path: page/p
en: This TreeView displays a TreeStore with two columns, one of which is rendered as a toggle.
cs: Tento widget <code>TreeView</code> zobrazuje <code>TreeStore</code> se dvěma sloupci, z nichž jeden je vykreslován jako přepínač.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Pango
    import sys
    
    books = [["Tolstoy, Leo", ["War and Peace", True], ["Anna Karenina", False]],
             ["Shakespeare, William", ["Hamlet", False],
                 ["Macbeth", True], ["Othello", False]],
             ["Tolkien, J.R.R.", ["The Lord of the Rings", False]]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Library", application=app)
            self.set_default_size(250, 100)
            self.set_border_width(10)
    
            # the data are stored in the model
            # create a treestore with two columns
            self.store = Gtk.TreeStore(str, bool)
            # fill in the model
            for i in range(len(books)):
                # the iter piter is returned when appending the author in the first column
                # and False in the second
                piter = self.store.append(None, [books[i][0], False])
                # append the books and the associated boolean value as children of
                # the author
                j = 1
                while j &lt; len(books[i]):
                    self.store.append(piter, books[i][j])
                    j += 1
    
            # the treeview shows the model
            # create a treeview on the model self.store
            view = Gtk.TreeView()
            view.set_model(self.store)
    
            # the cellrenderer for the first column - text
            renderer_books = Gtk.CellRendererText()
            # the first column is created
            column_books = Gtk.TreeViewColumn("Books", renderer_books, text=0)
            # and it is appended to the treeview
            view.append_column(column_books)
    
            # the cellrenderer for the second column - boolean rendered as a toggle
            renderer_in_out = Gtk.CellRendererToggle()
            # the second column is created
            column_in_out = Gtk.TreeViewColumn("Out?", renderer_in_out, active=1)
            # and it is appended to the treeview
            view.append_column(column_in_out)
            # connect the cellrenderertoggle with a callback function
            renderer_in_out.connect("toggled", self.on_toggled)
    
            # add the treeview to the window
            self.add(view)
    
        # callback function for the signal emitted by the cellrenderertoggle
        def on_toggled(self, widget, path):
            # the boolean value of the selected row
            current_value = self.store[path][1]
            # change the boolean value of the selected row in the model
            self.store[path][1] = not current_value
            # new current value!
            current_value = not current_value
            # if length of the path is 1 (that is, if we are selecting an author)
            if len(path) == 1:
                # get the iter associated with the path
                piter = self.store.get_iter(path)
                # get the iter associated with its first child
                citer = self.store.iter_children(piter)
                # while there are children, change the state of their boolean value
                # to the value of the author
                while citer is not None:
                    self.store[citer][1] = current_value
                    citer = self.store.iter_next(citer)
            # if the length of the path is not 1 (that is, if we are selecting a
            # book)
            elif len(path) != 1:
                # get the first child of the parent of the book (the first book of
                # the author)
                citer = self.store.get_iter(path)
                piter = self.store.iter_parent(citer)
                citer = self.store.iter_children(piter)
                # check if all the children are selected
                all_selected = True
                while citer is not None:
                    if self.store[citer][1] == False:
                        all_selected = False
                        break
                    citer = self.store.iter_next(citer)
                # if they do, the author as well is selected; otherwise it is not
                self.store[piter][1] = all_selected
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Pango
    import sys
    
    books = [["Tolstoy, Leo", ["War and Peace", True], ["Anna Karenina", False]],
             ["Shakespeare, William", ["Hamlet", False],
                 ["Macbeth", True], ["Othello", False]],
             ["Tolkien, J.R.R.", ["The Lord of the Rings", False]]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Library", application=app)
            self.set_default_size(250, 100)
            self.set_border_width(10)
    
            # Data jsou uložena v modelu
            # Vytvoří stromové zobrazení se dvěma sloupci
            self.store = Gtk.TreeStore(str, bool)
            # Naplní model
            for i in range(len(books)):
                # Iterátor piter je vrácen, kdy se připojuje autor v prvním sloupci
                # a hodnota False ve druhém sloupci
                piter = self.store.append(None, [books[i][0], False])
                # Připojí knihy a přidruženou pravdivostní hodnotu jako potomky
                # autora
                j = 1
                while j &lt; len(books[i]):
                    self.store.append(piter, books[i][j])
                    j += 1
    
            # TreeView zobrazuje model
            # Vytvoří stromové zobrazení na modelu self.store
            view = Gtk.TreeView()
            view.set_model(self.store)
    
            # Vykreslovač pro první sloupec - text
            renderer_books = Gtk.CellRendererText()
            # Vytvoří první sloupec
            column_books = Gtk.TreeViewColumn("Books", renderer_books, text=0)
            # A připojí jej do stromového zobrazení
            view.append_column(column_books)
    
            # Vykreslovat pro druhý sloupec - pravdivostní hodnota jako přepínač
            renderer_in_out = Gtk.CellRendererToggle()
            # Vytvoří druhý sloupec
            column_in_out = Gtk.TreeViewColumn("Out?", renderer_in_out, active=1)
            # A připojí jej do stromového zobrazení
            view.append_column(column_in_out)
            # Napojí signál "toggled" na funkci zpětného volání
            renderer_in_out.connect("toggled", self.on_toggled)
    
            # Přidá stromové zobrazení do okna
            self.add(view)
    
        # Funkce zpětného volání pro signál vyslaný od CellRendererToggle
        def on_toggled(self, widget, path):
            # Pravdivostní hodnota vybraného řádku
            current_value = self.store[path][1]
            # Změní pravdivostní hodnotu vybraného řádku v modelu
            self.store[path][1] = not current_value
            # Nová aktuální hodnota!
            current_value = not current_value
            # Jestliže je délka cesty 1 (tj. je vybrán autor)
            if len(path) == 1:
                # Získá iterátor patřící cestě
                piter = self.store.get_iter(path)
                # Získá iterátor patřící jejímu prvnímu potomkovi
                citer = self.store.iter_children(piter)
                # Dokud existují potomoci, mění stav jejich pravdivostních hodnot
                # na hodnotu u autora
                while citer is not None:
                    self.store[citer][1] = current_value
                    citer = self.store.iter_next(citer)
            # Jestliže délka cesty naní 1 (tj. je vybrána kniha)
            elif len(path) != 1:
                # Získá prvního potomka od rodiče knihy (první kniha autora)
                citer = self.store.get_iter(path)
                piter = self.store.iter_parent(citer)
                citer = self.store.iter_children(piter)
                # Zkontroluje, jestli jsou vybráni všichni potomci
                all_selected = True
                while citer is not None:
                    if self.store[citer][1] == False:
                        all_selected = False
                        break
                    citer = self.store.iter_next(citer)
                # Pokud ano, je vybrán i autor, jinak ne
                self.store[piter][1] = all_selected
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/p
en: In line 48 the <code>"toggled"</code> signal is connected to the callback function <code>on_toggled()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 48 je signál <code>"toggled"</code> napojen na funkci zpětného volání <code>on_toggled()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

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

note: (itstool) path: info/desc
en: A widget that shows a separate list of items
cs: Widget, který zobrazuje samostatný seznam položek

note: (itstool) path: page/title
en: TreeView with ListStore
cs: TreeView s ListStore

note: (itstool) path: page/p
en: A TreeView is like a window onto the contents of either a ListStore or a TreeStore. A ListStore is like a spreadsheet: a "flat", two-dimensional list of things broken up into rows and columns. A TreeStore, meanwhile, can branch out in different directions like a tree can. In this example, we create a TreeView that shows the contents of a ListStore with (fictitious) names and phone numbers in it, and set it so that the <link xref="label.js">Label</link> at the bottom of the window shows more information about whichever name you click on.
cs: <code>TreeView</code> (stromové zobrazení) je něco jako okno do obsahu úložiště <code>ListStore</code> nebo <code>TreeStore</code>. <code>ListStore</code> je podobný tabulce: „plochý“ dvourozměrný seznam věcí rozdělených do řádků a sloupců. <code>TreeStore</code> se oproti němu může větvit do různých směrů podobně jako strom. V tomto příkladu vytvoříme <code>TreeView</code> zobrazující obsah <code>ListStore</code> se (smyšlenými) jmény a telefonními čísly a k tomu widget <link xref="label.js">Label</link> ve spodní části okna, který bude zobrazovat více informací ke jménu, na které v seznamu kliknete.

note: (itstool) path: page/p
en: The TreeView is not just a single widget, but contains a number of smaller ones:
cs: <code>TreeView</code> ve skutečnosti není jeden widget, ale obsahuje řadu dalších menších:

note: (itstool) path: item/p
en: TreeViewColumn widgets show each (vertical) column of information from the ListStore. Each one has a title which can be shown at the top of the column, like in the screenshot.
cs: Widgety <code>TreeViewColumn</code> (sloupec stromového zobrazení) zobrazují jednotlivé (svislé) sloupce s údaji z <code>ListStore</code>. Každý má záhlaví, které může být zobrazené nad sloupcem, podobně jako na snímku obrazovky.

note: (itstool) path: item/p
en: CellRenderer widgets are "packed" into each TreeViewColumn, and contain the instructions for how to display each individual "cell", or item from the ListStore. There are multiple different types, including the CellRendererText used here and the CellRendererPixbuf, which displays a picture ("pixel buffer").
cs: Widgety <code>CellRenderer</code> (vykreslovač buňky) jsou „zabaleny“ do jednotlivých <code>TreeViewColumn</code> a obsahují instrukce, jak zobrazovat jednotlivé „buňky“ nebo položky z <code>ListStore</code>. Existuje jich více různých typů, včetně <code>CellRendererText</code> použitého zde a <code>CellRendererPixbuf</code>, který zobrazuje obrázky (pixbuf).

note: (itstool) path: page/p
en: Finally, we're going to use an object called a TreeIter, which isn't a widget so much as an invisible cursor which points to a (horizontal) row in the ListStore. Whenever you click on a name in the phonebook, for instance, we create a TreeIter pointing to the row that's selected, and then use that to tell the ListStore which entry we want the Label to show more information about.
cs: A navíc budeme použít objekt nazvaný <code>TreeIter</code>, což není ani tak widget, jako neviditelný kurzor, který ukazuje na (vodorovný) řádek v <code>ListStore</code>. Kdykoliv například kliknete na jméno v adresáři, vytvoříme <code>TreeIter</code> ukazující na řádek, který je vybrán a použijeme jej, abychom řekli úložišti, který záznam chceme pro popisek zobrazující o záznamech více informací.

note: (itstool) path: note/p
en: The TreeView is probably the most complicated Gtk widget, because of how many parts it has and how they all have to work together. Give yourself time to learn how it works and experiment with it, or try something easier first if you're having trouble.
cs: <code>TreeView</code> je pravděpodobně nejsložitější widget v Gtk tím, jakou má spoustu částí a jak ty spolupracují. Věnujte chvilku času studiu, jak funguje a experimentujte s ním, nebo, když s ním budete mít problémy, zkuste nejdřív něco jednoduššího.

note: (itstool) path: section/code
en: 
    const TreeViewExample = new Lang.Class({
        Name: 'TreeView Example with Simple ListStore',
    
        // Create the application itself
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstreeviewsimpleliststore'
            });
    
        // Connect 'activate' and 'startup' signals to the callback functions
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Callback function for 'activate' signal presents window when active
        _onActivate: function() {
            this._window.present();
        },
    
        // Callback function for 'startup' signal builds the UI
        _onStartup: function() {
            this._buildUI ();
        },
cs: 
    const TreeViewExample = new Lang.Class({
        Name: 'TreeView Example with Simple ListStore',
    
        // Vytvoří vlastní aplikaci
        _init: function() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstreeviewsimpleliststore'
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
        this.application.connect('activate', Lang.bind(this, this._onActivate));
        this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate: function() {
            this._window.present();
        },
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup: function() {
            this._buildUI ();
        },

note: (itstool) path: section/p
en: All the code for this sample goes in the TreeViewExample class. The above code creates a <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> for our widgets and window to go in.
cs: Všechen kód této ukázky je ve třídě TreeViewExample. Výše uvedený kód vytvoří <link href="http://www.roojs.com/seed/gir-1.2-gtk-3.0/gjs/Gtk.Application.html">Gtk.Application</link> pro naše widgety a okno, ve kterém budou.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI: function() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 250,
                default_width: 100,
                border_width: 20,
                title: "My Phone Book"});
cs: 
        // Sestaví uživatelské rozhraní aplikace
        _buildUI: function() {
    
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 250,
                default_width: 100,
                border_width: 20,
                title: "My Phone Book"});

note: (itstool) path: section/code
en: 
            // Create the underlying liststore for the phonebook
            this._listStore = new Gtk.ListStore ();
            this._listStore.set_column_types ([
                GObject.TYPE_STRING,
                GObject.TYPE_STRING,
                GObject.TYPE_STRING,
                GObject.TYPE_STRING]);
cs: 
            // Vytvoří podkladový ListStore pro telefonní seznam
            this._listStore = new Gtk.ListStore ();
            this._listStore.set_column_types ([
                GObject.TYPE_STRING,
                GObject.TYPE_STRING,
                GObject.TYPE_STRING,
                GObject.TYPE_STRING]);

note: (itstool) path: section/p
en: We first create the ListStore like we would any widget. Then we call its set_column_types method, and pass it an array of GObject data types. (We could have put the types all on one line, but here we are breaking them up to make it easier to read.)
cs: Nejprve vytvořím seznamové úložiště obdobně, jako kterýkoliv jiný widget. Pak zavoláme jeho metodu <code>set_column_types</code> a předáme ji pole datových typů <code>GObject</code>. (Mohli bychom je mít všechny na jednom řádku, ale zde je kvůli snadnějšímu čtení rozdělíme.)

note: (itstool) path: section/p
en: The GObject data types you can use include:
cs: Mezi datové typy GObject, které můžete použít, patří:

note: (itstool) path: item/p
en: <file>gtk.gdk.Pixbuf</file> -- A picture
cs: <file>gtk.gdk.Pixbuf</file> – Obrázek

note: (itstool) path: section/p
en: In this case, we're making a ListStore of four columns, each one containing string values.
cs: V tomto případě vytváříme seznamové úložiště se čtyřmi sloupci, přičemž všechny obsahují řetězcové hodnoty.

note: (itstool) path: section/code
en: 
            // Data to go in the phonebook
            this.phonebook =
            let phonebook =
                [{ name: "Jurg", surname: "Billeter", phone: "555-0123",
                    description: "A friendly person."},
                 { name: "Johannes", surname: "Schmid", phone: "555-1234",
                    description: "Easy phone number to remember."},
                 { name: "Julita", surname: "Inca", phone: "555-2345",
                    description: "Another friendly person."},
                 { name: "Javier", surname: "Jardon", phone: "555-3456",
                    description: "Bring fish for his penguins."},
                 { name: "Jason", surname: "Clinton", phone: "555-4567",
                    description: "His cake's not a lie."},
                 { name: "Random J.", surname: "Hacker", phone: "555-5678",
                    description: "Very random!"}];
cs: 
            // Data do telefonního seznamu
            this.phonebook =
            let phonebook =
                [{ name: "Jurg", surname: "Billeter", phone: "555-0123",
                    description: "A friendly person."},
                 { name: "Johannes", surname: "Schmid", phone: "555-1234",
                    description: "Easy phone number to remember."},
                 { name: "Julita", surname: "Inca", phone: "555-2345",
                    description: "Another friendly person."},
                 { name: "Javier", surname: "Jardon", phone: "555-3456",
                    description: "Bring fish for his penguins."},
                 { name: "Jason", surname: "Clinton", phone: "555-4567",
                    description: "His cake's not a lie."},
                 { name: "Random J.", surname: "Hacker", phone: "555-5678",
                    description: "Very random!"}];

note: (itstool) path: section/p
en: Here we have the information to go in the ListStore. It's an array of objects, each one corresponding to a single entry in our phone book.
cs: Zde máme údaje, které přijdou do seznamového úložiště. Jedná se o pole objektů, kdy každý odpovídá jednomu záznamu v adresáři.

note: (itstool) path: section/p
en: Note that the TreeView in the screenshot doesn't actually show the data from the "description" properties. Instead, that information's shown in the Label beneath it, for whichever row that you click on. That's because the TreeView and ListStore are two separate things, and a TreeView can show all or part of a ListStore, and display what's in it in different ways. You can even have multiple widgets show things from the same ListStore, like the Label in our example or even a second TreeView.
cs: Všimněte si, že stromové zobrazení na snímku obrazovky ve skutečnosti nezobrazuje data z vlastnosti „description“. Místo toho je tato vlastnost zobrazena v popisku pod ním a to pro řádek, na který jste klikli. To je proto, že <code>TreeView</code> a <code>ListStore</code> jsou dvě oddělené věci, a stromové zobrazení může zobrazovat všechny nebo jen některé sloupce ze seznamového úložiště a může je zobrazovat různými způsoby. Na druhou stranu můžete mít více widgetů, které budou zobrazovat věci z téhož <code>ListStore</code>, podobně jako <code>Label</code> v našem příkladu, nebo třeba klidně druhý <code>TreeView</code>.

note: (itstool) path: section/p
en: This <file>for</file> loop puts the strings from our phonebook into our ListStore in order. In order, we pass the ListStore's set method the iter that points to the correct row, an array which says which columns we want to set, and an array which contains the data we want to put into those columns.
cs: Tato smyčka <code>for</code> vkládá řetězce z našeho adresáře do seznamového úložiště ve správném pořadí. Metodě <code>set</code> úložiště předáváme iterátor ukazující na správný řádek, pole říkající, které sloupce chceme nastavit, a pole obsahující data, která chceme do těchto sloupců vložit.

note: (itstool) path: section/p
en: A ListStore's <file>append</file> method adds a horizontal row onto it (it starts out with none), and returns a TreeIter pointing to that row like a cursor. So by passing <file>this._listStore.append()</file> to the ListStore as a property, we're creating a new row and telling the <file>set</file> method which row to set data for at the same time.
cs: Metoda <code>append</code> objektu <code>ListStore</code> přidává vodorovný řádek (na začátku je bez řádků) a vrací <code>TreeIter</code> ukazující na tento nový řádek. Takže předáním <code>this._listStore.append()</code> do seznamového úložiště jako vlastnosti vytvoříme nový řádek a zároveň řekneme metodě <code>set</code>, která data má do řádku vložit.

note: (itstool) path: section/title
en: Creating the TreeView
cs: Vytvoření TreeView

note: (itstool) path: section/code
en: 
            // Create the treeview
            this._treeView = new Gtk.TreeView ({
                expand: true,
                model: this._listStore });
cs: 
            // Vytvoří stromové zobrazení
            this._treeView = new Gtk.TreeView ({
                expand: true,
                model: this._listStore });

note: (itstool) path: section/p
en: Here we create a basic TreeView widget, that expands both horizontally and vertically to use as much space as needed. We set it to use the ListStore we created as its "model", or the thing it'll show us stuff from.
cs: Zde vytvoříme základní widget <code>TreeView</code>, který se roztáhne ve vodorovném i svislém směru, aby zabral co nejvíce místa může. Nastavíme, aby používal <code>ListStore</code>, který jsme vytvořili jako jeho „model“ neboli věc, ze které se budou věci zobrazovat.

note: (itstool) path: section/code
en: 
            // Create the columns for the address book
            let firstName = new Gtk.TreeViewColumn ({ title: "First Name" });
            let lastName = new Gtk.TreeViewColumn ({ title: "Last Name" });
            let phone = new Gtk.TreeViewColumn ({ title: "Phone Number" });
cs: 
            // Vytvoří sloupce pro telefonní seznam
            let firstName = new Gtk.TreeViewColumn ({ title: "First Name" });
            let lastName = new Gtk.TreeViewColumn ({ title: "Last Name" });
            let phone = new Gtk.TreeViewColumn ({ title: "Phone Number" });

note: (itstool) path: section/p
en: Now we create each of the vertical TreeViewColumns we'll see in the TreeView. The title for each one goes at the top, as you can see in the screenshot.
cs: Nyní vytvoříme jednotlivé svislé sloupce <code>TreeViewColumn</code>, které ve stromovém zobrazení vidíme. Názvy jednotlivých sloupců se objeví v záhlaví, jak můžete vidět na snímku obrazovky.

note: (itstool) path: section/code
en: 
            // Create a cell renderer for when bold text is needed
            let bold = new Gtk.CellRendererText ({
                weight: Pango.Weight.BOLD });
    
            // Create a cell renderer for normal text
            let normal = new Gtk.CellRendererText ();
    
            // Pack the cell renderers into the columns
            firstName.pack_start (bold, true);
            lastName.pack_start (normal, true);
            phone.pack_start (normal, true);
cs: 
            // Vytvoří vykreslovač buňky pro potřeby tučného textu
            let bold = new Gtk.CellRendererText ({
                weight: Pango.Weight.BOLD });
    
            // Vytvoří vykreslovač buňky pro normální text
            let normal = new Gtk.CellRendererText ();
    
            // Zabalí vykreslovače buněk ke sloupcům
            firstName.pack_start (bold, true);
            lastName.pack_start (normal, true);
            phone.pack_start (normal, true);

note: (itstool) path: section/p
en: Here we create the CellRenderers that we'll use to display the text from our ListStore, and pack them into the TreeViewColumns. Each CellRendererText is used for all the entries in that column. Our normal CellRendererText just creates plain text, while our bold one uses heavier-weight text. We put it into the first name column, and tell the other two to use copies of the normal one. The "true" used as the second parameter for the <file>pack_start</file> method tells it to expand the cells when possible, instead of keeping them compact.
cs: Zde vytváříme vykreslovače <code>CellRenderer</code>, které použijeme k zobrazení textu z <code>ListStore</code>, a balíme je do příslušných <code>TreeViewColumn</code>. Každý <code>CellRendererText</code> je použit pro všechny záznamy ve sloupci. Náš normální <code>CellRendererText</code> jen vytvoří prostý text, zatímco ten pro tučný text použije text se změněnou vlastností weight. Ten vložíme do prvního sloupce a ostatním dvoum řekneme, aby používali kopie toho normálního. V metodě <code>pack_start</code> je jako druhý parametr použita hodnota <code>true</code>, která říká, že má roztáhnout buňku co nejvíce to jde, místo, aby ji udržovala kompaktní.

note: (itstool) path: note/p
en: <link href="http://www.pygtk.org/docs/pygtk/pango-constants.html">Here is a list</link> of other text properties you can use. In order to use these Pango constants, make sure to put the line <file>const Pango = imports.gi.Pango;</file> at the beginning of your code like we did.
cs: <link href="http://www.pygtk.org/docs/pygtk/pango-constants.html">Zde je seznam</link> dalších vlastností textu, které můžete použít. Abyste mohli tyto konstanty používat, musíte vložit řádek <code>const Pango = imports.gi.Pango;</code> na začátek svého kódu.

note: (itstool) path: section/code
en: 
            firstName.add_attribute (bold, "text", 0);
            lastName.add_attribute (normal, "text", 1);
            phone.add_attribute (normal, "text", 2);
    
            // Insert the columns into the treeview
            this._treeView.insert_column (firstName, 0);
            this._treeView.insert_column (lastName, 1);
            this._treeView.insert_column (phone, 2);
cs: 
            firstName.add_attribute (bold, "text", 0);
            lastName.add_attribute (normal, "text", 1);
            phone.add_attribute (normal, "text", 2);
    
            // Vloží sloupce do treeview
            this._treeView.insert_column (firstName, 0);
            this._treeView.insert_column (lastName, 1);
            this._treeView.insert_column (phone, 2);

note: (itstool) path: section/p
en: Now that we've put the CellRenderers into the TreeViewColumns, we use the <file>add_attribute</file> method to tell each column to pull in text from the model our TreeView is set to use; in this case, the ListStore with the phonebook.
cs: Nyní vložíme jednotlivé <code>CellRenderer</code> do příslušných <code>TreeViewColumn</code>. Použijeme metodu <code>add_attribute</code>, která jednotlivým sloupcům říká, aby si vytáhli text z modelu našeho stromového zobrazení, které se používá (v tomto případě <code>ListStore</code> s adresářem).

note: (itstool) path: item/p
en: The first parameter is which CellRenderer we're going to use to render what we're pulling in.
cs: První parametr je vykreslovač buňky, který hodláme použít k vykreslení toho, co jsme vytáhli.

note: (itstool) path: item/p
en: The second parameter is what kind of information we're going to pull in. In this case, we're letting it know that we're rendering text.
cs: Druhým parametrem je druh informací, které vytahujeme. V tomto případě vězte, že vykreslujeme text.

note: (itstool) path: item/p
en: The third parameter is which of the ListStore's columns we're pulling that information in from.
cs: Třetím parametrem je číslo sloupce seznamového úložiště, ze kterého se data mají vytahovat.

note: (itstool) path: section/p
en: After we've set that up, we use the TreeView's <file>insert_column</file> method to put our TreeViewColumns inside it in order. Our TreeView is now complete.
cs: Po té, co jsme toto nastavili, použijeme metodu <code>insert_column</code> stromového zobrazení k vložení našich sloupců <code>TreeViewColumn</code> do něj ve správném pořadí. Nyní je náš stromový pohled kompletní.

note: (itstool) path: note/p
en: Normally, you might want to use a loop to initialize your TreeView, but in this example we're spelling things out step by step for the sake of making it easier to understand.
cs: Normálně byste asi chtěli použít k inicializaci svého stromového pohledu smyčku, ale v tomto příkladu to provedeme krok za krokem v zájmu snazšího pochopení.

note: (itstool) path: section/title
en: Building the rest of the UI
cs: Sestavení zbytku uživatelského rozhraní

note: (itstool) path: section/code
en: 
            // Create the label that shows details for the name you select
            this._label = new Gtk.Label ({ label: "" });
    
            // Get which item is selected
            this.selection = this._treeView.get_selection();
    
            // When something new is selected, call _on_changed
            this.selection.connect ('changed', Lang.bind (this, this._onSelectionChanged));
cs: 
            // Vytvoří popisek, který zobrazuje podrobnosti ke jménu, které jste vybrali
            this._label = new Gtk.Label ({ label: "" });
    
            // Vrátí, která položka je vybrána
            this.selection = this._treeView.get_selection();
    
            // Když je vybráno něco nového, zavolá _on_changed
            this.selection.connect ('changed', Lang.bind (this, this._onSelectionChanged));

note: (itstool) path: section/p
en: The TreeView's <file>get_selection</file> method returns an object called a TreeSelection. A TreeSelection is like a TreeIter in that it's basically a cursor that points at a particular row, except that the one it points to is the one that's visibly highlighted as selected.
cs: Metoda <code>get_selection</code> widgetu <code>TreeView</code> vrací objekt nazvaný <code>TreeSelection</code>. Ten je, podobně jako <code>TreeIter</code>, v podstatě kurzor ukazující na konkrétní řádek, vyjma toho, že tento ukazuje na řádek vizuálně zvýrazněný jako vybraný.

note: (itstool) path: section/p
en: After we get the TreeSelection that goes with our TreeView, we ask it to tell us when it changes which row it's pointing to. We do this by connecting its <file>changed</file> signal to the _onSelectionChanged function we wrote. This function changes the text displayed by the Label we just made.
cs: Po té, co získáme objekt <code>TreeSelection</code>, které patří našemu stromovému zobrazení, řekneme mu, aby nám sděloval změny v řádku, na který ukazuje. Uděláme to napojením jeho signálu <code>"changed"</code> na funkci <code>_onSelectionChanged</code>, kterou jsme napsali. Tato funkce mění text zobrazený v popisku, který jsme právě vytvořili.

note: (itstool) path: section/code
en: 
            // Create a grid to organize everything in
            this._grid = new Gtk.Grid;
    
            // Attach the treeview and label to the grid
            this._grid.attach (this._treeView, 0, 0, 1, 1);
            this._grid.attach (this._label, 0, 1, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
        },
cs: 
            // Vytvoří mřížku, do které vše uspořádáme
            this._grid = new Gtk.Grid;
    
            // Připojí stromové zobrazení a popisek do mřížky
            this._grid.attach (this._treeView, 0, 0, 1, 1);
            this._grid.attach (this._label, 0, 1, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        },

note: (itstool) path: section/p
en: After we've gotten that out of the way, we create a <link xref="grid.js">Grid</link> to put everything in, then add it to our window and tell the window to show itself and its contents.
cs: Po té, co jsem tohle vyřešili, vytvoříme <link xref="grid.js">Grid</link>, do které vše vložíme, a pak ji přidáme do našeho okna a oknu řekneme, aby zobrazilo sebe i svůj obsah.

note: (itstool) path: section/title
en: Function which handles a changed selection
cs: Funkce, která obsluhuje změnu výběru

note: (itstool) path: section/code
en: 
        _onSelectionChanged: function () {
    
            // Grab a treeiter pointing to the current selection
            let [ isSelected, model, iter ] = this.selection.get_selected();
    
            // Set the label to read off the values stored in the current selection
            this._label.set_label ("\n" +
                this._listStore.get_value (iter, 0) + " " +
                this._listStore.get_value (iter, 1) + " " +
                this._listStore.get_value (iter, 2) + "\n" +
                this._listStore.get_value (iter, 3));
    
        }
    
    });
cs: 
        _onSelectionChanged: function () {
    
            // Získá iteraci stromového zobrazení ukazující na aktuální výběr
            let [ isSelected, model, iter ] = this.selection.get_selected();
    
            // Nastaví popisek, aby vytáhl údaje uchované v aktuálním výběru
            this._label.set_label ("\n" +
                this._listStore.get_value (iter, 0) + " " +
                this._listStore.get_value (iter, 1) + " " +
                this._listStore.get_value (iter, 2) + "\n" +
                this._listStore.get_value (iter, 3));
    
        }
    
    });

note: (itstool) path: section/p
en: The line of code with the let statement is a little convoluted, but it's nonetheless the best way to get a TreeIter pointing to the same row as our TreeSelection. It has to create a couple of other object references, but <file>iter</file> is the only one we need.
cs: Řádek s výrazem <code>let</code> je poněkud spletitý, nicméně je to nejlepší způsob, jak získat <code>TreeIter</code> ukazující na stejný řádek jako náš <code>TreeSelection</code>. Vytvoří n-tici dalších odkazů na objekty, ale <code>iter</code> je jediný, který nás zajímá.

note: (itstool) path: section/p
en: After we've done that, we call the Label's <file>set_label</file> function, and use the ListStore's <file>get_value</file> function a handful of times to fill in the data we want to put in it. Its parameters are a TreeIter pointing to the row we want to get data from, and the column.
cs: Když máme toto hotovo, zavoláme funkci <code>set_label</code> z widgetu <code>Label</code> a použijeme funkci <code>get_value</code> z <code>ListStore</code> patřičně krát k vyplnění dat, která chceme do popisku vložit. Jejím parametrem jsou stromový iterátor, který ukazuje na řádek, ze kterého data chceme, a sloupec.

note: (itstool) path: section/p
en: Here, we want to get data from all four columns, including the "hidden" one that's not part of the TreeView. This way, we can use our Label to show strings that are too large to fit in the TreeView, and that we don't need to see at a glance.
cs: Zde chceme získat data ze čtyř sloupců, včetně jednoho „skrytého“, který není součástí stromového zobrazení. Tímto způsobem můžeme použít náš popisek, aby zobrazil řetězce, které jsou příliš dlouhé na to, aby byly vidět ve stromovém zobrazení, a ty, které nepotřebujeme v přehledu vidět.

note: (itstool) path: section/code
en: 
    // Run the application
    let app = new TreeViewExample ();
    app.application.run (ARGV);
cs: 
    // Spustí aplikaci
    let app = new TreeViewExample ();
    app.application.run (ARGV);

note: (itstool) path: section/p
en: Finally, we create a new instance of the finished TreeViewExample class, and set the application running.
cs: Nakonec vytvoříme novou instanci konečné třídy TreeViewExample a aplikaci spustíme.

note: (itstool) path: section/code
en: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const GObject = imports.gi.GObject;
    const Gtk = imports.gi.Gtk;
    const Pango = imports.gi.Pango;
    
    class TreeViewExample {
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstreeviewsimpleliststore'
            });
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI();
        }
    
        // Build the application's UI
        _buildUI() {
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 250,
                default_width: 100,
                border_width: 20,
                title: "My Phone Book"});
    
            // Create the underlying liststore for the phonebook
            this._listStore = new Gtk.ListStore ();
            this._listStore.set_column_types ([
                GObject.TYPE_STRING,
                GObject.TYPE_STRING,
                GObject.TYPE_STRING,
                GObject.TYPE_STRING]);
    
            // Data to go in the phonebook
            let phonebook =
                [{ name: "Jurg", surname: "Billeter", phone: "555-0123",
                    description: "A friendly person."},
                 { name: "Johannes", surname: "Schmid", phone: "555-1234",
                    description: "Easy phone number to remember."},
                 { name: "Julita", surname: "Inca", phone: "555-2345",
                    description: "Another friendly person."},
                 { name: "Javier", surname: "Jardon", phone: "555-3456",
                    description: "Bring fish for his penguins."},
                 { name: "Jason", surname: "Clinton", phone: "555-4567",
                    description: "His cake's not a lie."},
                 { name: "Random J.", surname: "Hacker", phone: "555-5678",
                    description: "Very random!"}];
    
            // Put the data in the phonebook
            for (let i = 0; i &lt; phonebook.length; i++ ) {
                let contact = phonebook [i];
                this._listStore.set (this._listStore.append(), [0, 1, 2, 3],
                    [contact.name, contact.surname, contact.phone, contact.description]);
            }
    
            // Create the treeview
            this._treeView = new Gtk.TreeView ({
                expand: true,
                model: this._listStore });
    
            // Create the columns for the address book
            let firstName = new Gtk.TreeViewColumn ({ title: "First Name" });
            let lastName = new Gtk.TreeViewColumn ({ title: "Last Name" });
            let phone = new Gtk.TreeViewColumn ({ title: "Phone Number" });
    
            // Create a cell renderer for when bold text is needed
            let bold = new Gtk.CellRendererText ({
                weight: Pango.Weight.BOLD });
    
            // Create a cell renderer for normal text
            let normal = new Gtk.CellRendererText ();
    
            // Pack the cell renderers into the columns
            firstName.pack_start (bold, true);
            lastName.pack_start (normal, true);
            phone.pack_start (normal, true);
    
            // Set each column to pull text from the TreeView's model
            firstName.add_attribute (bold, "text", 0);
            lastName.add_attribute (normal, "text", 1);
            phone.add_attribute (normal, "text", 2);
    
            // Insert the columns into the treeview
            this._treeView.insert_column (firstName, 0);
            this._treeView.insert_column (lastName, 1);
            this._treeView.insert_column (phone, 2);
    
            // Create the label that shows details for the name you select
            this._label = new Gtk.Label ({ label: "" });
    
            // Get which item is selected
            this.selection = this._treeView.get_selection();
    
            // When something new is selected, call _on_changed
            this.selection.connect ('changed', this._onSelectionChanged.bind(this));
    
            // Create a grid to organize everything in
            this._grid = new Gtk.Grid;
    
            // Attach the treeview and label to the grid
            this._grid.attach (this._treeView, 0, 0, 1, 1);
            this._grid.attach (this._label, 0, 1, 1, 1);
    
            // Add the grid to the window
            this._window.add (this._grid);
    
            // Show the window and all child widgets
            this._window.show_all();
        }
    
        _onSelectionChanged() {
            // Grab a treeiter pointing to the current selection
            let [ isSelected, model, iter ] = this.selection.get_selected();
    
            // Set the label to read off the values stored in the current selection
            this._label.set_label ("\n" +
                this._listStore.get_value (iter, 0) + " " +
                this._listStore.get_value (iter, 1) + " " +
                this._listStore.get_value (iter, 2) + "\n" +
                this._listStore.get_value (iter, 3)
            );
        }
    };
    
    // Run the application
    let app = new TreeViewExample ();
    app.application.run (ARGV);
cs: #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const GObject = imports.gi.GObject;
    const Gtk = imports.gi.Gtk;
    const Pango = imports.gi.Pango;
    
    class TreeViewExample {
        // Vytvoří vlastní aplikaci
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.jstreeviewsimpleliststore'
            });
    
        // Napojí signály "activate" a "startup" k funkcím zpětného volání
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate" zobrazujicí okno při aktivaci
        _onActivate() {
            this._window.present();
        }
    
        // Funkce zpětného volání pro signál "startup" sestavující uživatelské rozhraní
        _onStartup() {
            this._buildUI();
        }
    
        // Sestaví uživatelské rozhraní aplikace
        _buildUI() {
            // Vytvoří okno aplikace
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                default_height: 250,
                default_width: 100,
                border_width: 20,
                title: "My Phone Book"});
    
            // Vytvoří podkladový ListStore pro telefonní seznam
            this._listStore = new Gtk.ListStore ();
            this._listStore.set_column_types ([
                GObject.TYPE_STRING,
                GObject.TYPE_STRING,
                GObject.TYPE_STRING,
                GObject.TYPE_STRING]);
    
            // Data do telefonního seznamu
            let phonebook =
                [{ name: "Jurg", surname: "Billeter", phone: "555-0123",
                    description: "A friendly person."},
                 { name: "Johannes", surname: "Schmid", phone: "555-1234",
                    description: "Easy phone number to remember."},
                 { name: "Julita", surname: "Inca", phone: "555-2345",
                    description: "Another friendly person."},
                 { name: "Javier", surname: "Jardon", phone: "555-3456",
                    description: "Bring fish for his penguins."},
                 { name: "Jason", surname: "Clinton", phone: "555-4567",
                    description: "His cake's not a lie."},
                 { name: "Random J.", surname: "Hacker", phone: "555-5678",
                    description: "Very random!"}];
    
            // Vloží data do telefonního seznamu
            for (let i = 0; i &lt; phonebook.length; i++ ) {
                let contact = phonebook [i];
                this._listStore.set (this._listStore.append(), [0, 1, 2, 3],
                    [contact.name, contact.surname, contact.phone, contact.description]);
            }
    
            // Vytvoří stromové zobrazení
            this._treeView = new Gtk.TreeView ({
                expand: true,
                model: this._listStore });
    
            // Vytvoří sloupce pro telefonní seznam
            let firstName = new Gtk.TreeViewColumn ({ title: "First Name" });
            let lastName = new Gtk.TreeViewColumn ({ title: "Last Name" });
            let phone = new Gtk.TreeViewColumn ({ title: "Phone Number" });
    
            // Vytvoří vykreslovač buňky pro potřeby tučného textu
            let bold = new Gtk.CellRendererText ({
                weight: Pango.Weight.BOLD });
    
            // Vytvoří vykreslovač buňky pro normální text
            let normal = new Gtk.CellRendererText ();
    
            // Zabalí vykreslovače buněk ke sloupcům
            firstName.pack_start (bold, true);
            lastName.pack_start (normal, true);
            phone.pack_start (normal, true);
    
            // Nastaví u každého sloupce, aby tahal text z modelu TreeView
            firstName.add_attribute (bold, "text", 0);
            lastName.add_attribute (normal, "text", 1);
            phone.add_attribute (normal, "text", 2);
    
            // Vloží sloupce do treeview
            this._treeView.insert_column (firstName, 0);
            this._treeView.insert_column (lastName, 1);
            this._treeView.insert_column (phone, 2);
    
            // Vytvoří popisek, který zobrazuje podrobnosti ke jménu, které jste vybrali
            this._label = new Gtk.Label ({ label: "" });
    
            // Vrátí, která položka je vybrána
            this.selection = this._treeView.get_selection();
    
            // Když je vybráno něco nového, zavolá _on_changed
            this.selection.connect ('changed', this._onSelectionChanged.bind(this));
    
            // Vytvoří mřížku, do které vše uspořádáme
            this._grid = new Gtk.Grid;
    
            // Připojí stromové zobrazení a popisek do mřížky
            this._grid.attach (this._treeView, 0, 0, 1, 1);
            this._grid.attach (this._label, 0, 1, 1, 1);
    
            // Přidá mřížku do okna
            this._window.add (this._grid);
    
            // Zobrazí okno a všechny jeho synovské widgety
            this._window.show_all();
        }
    
        _onSelectionChanged() {
            // Získá iteraci stromového zobrazení ukazující na aktuální výběr
            let [ isSelected, model, iter ] = this.selection.get_selected();
    
            // Nastaví popisek, aby vytáhl údaje uchované v aktuálním výběru
            this._label.set_label ("\n" +
                this._listStore.get_value (iter, 0) + " " +
                this._listStore.get_value (iter, 1) + " " +
                this._listStore.get_value (iter, 2) + "\n" +
                this._listStore.get_value (iter, 3)
            );
        }
    };
    
    // Spustí aplikaci
    let app = new TreeViewExample ();
    app.application.run (ARGV);

[ctx: text]
note: (itstool) path: info/title
en: Simple TreeView with ListStore (Python)
cs: Jednoduchý TreeView s ListStore (Python)

note: (itstool) path: info/desc
en: A TreeView displaying a ListStore (simpler example)
cs: TreeView zobrazující ListStore (jednodušší příklad)

note: (itstool) path: page/title
en: Simple TreeView with ListStore
cs: Jednoduchý TreeView s ListStore

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Pango
    import sys
    
    columns = ["First Name",
               "Last Name",
               "Phone Number"]
    
    phonebook = [["Jurg", "Billeter", "555-0123"],
                 ["Johannes", "Schmid", "555-1234"],
                 ["Julita", "Inca", "555-2345"],
                 ["Javier", "Jardon", "555-3456"],
                 ["Jason", "Clinton", "555-4567"],
                 ["Random J.", "Hacker", "555-5678"]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="My Phone Book", application=app)
            self.set_default_size(250, 100)
            self.set_border_width(10)
    
            # the data in the model (three strings for each row, one for each
            # column)
            listmodel = Gtk.ListStore(str, str, str)
            # append the values in the model
            for i in range(len(phonebook)):
                listmodel.append(phonebook[i])
    
            # a treeview to see the data stored in the model
            view = Gtk.TreeView(model=listmodel)
            # for each column
            for i, column in enumerate(columns):
                # cellrenderer to render the text
                cell = Gtk.CellRendererText()
                # the text in the first column should be in boldface
                if i == 0:
                    cell.props.weight_set = True
                    cell.props.weight = Pango.Weight.BOLD
                # the column is created
                col = Gtk.TreeViewColumn(column, cell, text=i)
                # and it is appended to the treeview
                view.append_column(col)
    
            # when a row is selected, it emits a signal
            view.get_selection().connect("changed", self.on_changed)
    
            # the label we use to show the selection
            self.label = Gtk.Label()
            self.label.set_text("")
    
            # a grid to attach the widgets
            grid = Gtk.Grid()
            grid.attach(view, 0, 0, 1, 1)
            grid.attach(self.label, 0, 1, 1, 1)
    
            # attach the grid to the window
            self.add(grid)
    
        def on_changed(self, selection):
            # get the model and the iterator that points at the data in the model
            (model, iter) = selection.get_selected()
            # set the label to a new value depending on the selection
            self.label.set_text("\n %s %s %s" %
                                (model[iter][0],  model[iter][1], model[iter][2]))
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Pango
    import sys
    
    columns = ["First Name",
               "Last Name",
               "Phone Number"]
    
    phonebook = [["Jurg", "Billeter", "555-0123"],
                 ["Johannes", "Schmid", "555-1234"],
                 ["Julita", "Inca", "555-2345"],
                 ["Javier", "Jardon", "555-3456"],
                 ["Jason", "Clinton", "555-4567"],
                 ["Random J.", "Hacker", "555-5678"]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="My Phone Book", application=app)
            self.set_default_size(250, 100)
            self.set_border_width(10)
    
            # Datový model (tři řetězce pro každý řádek, jeden na každý
            # slupec)
            listmodel = Gtk.ListStore(str, str, str)
            # Nasype do modelu hodnoty
            for i in range(len(phonebook)):
                listmodel.append(phonebook[i])
    
            # Stromové zobrazení pro zobrazení dat uložených v modelu
            view = Gtk.TreeView(model=listmodel)
            # Pro každý sloupec
            for i, column in enumerate(columns):
                # Vykreslovač buňky vykreslí text
                cell = Gtk.CellRendererText()
                # Text v prvním sloupci má být tučný
                if i == 0:
                    cell.props.weight_set = True
                    cell.props.weight = Pango.Weight.BOLD
                # Vytvoří sloupec
                col = Gtk.TreeViewColumn(column, cell, text=i)
                # Připojí sloupec do stromového zobrazení
                view.append_column(col)
    
            # Když je vybrán řádek, je vyslán signál
            view.get_selection().connect("changed", self.on_changed)
    
            # Popisek, který se používá k zobrazení výběru
            self.label = Gtk.Label()
            self.label.set_text("")
    
            # Mřížka pro připojení widgetů
            grid = Gtk.Grid()
            grid.attach(view, 0, 0, 1, 1)
            grid.attach(self.label, 0, 1, 1, 1)
    
            # Připojí mřížku do okna
            self.add(grid)
    
        def on_changed(self, selection):
            # Získá model a iterátor, který ukazuje na data v modelu
            (model, iter) = selection.get_selected()
            # Nastaví popisek na novou hodnotu podle výběru
            self.label.set_text("\n %s %s %s" %
                                (model[iter][0],  model[iter][1], model[iter][2]))
            return True
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/p
en: The TreeView widget is designed around a <em>Model/View/Controller</em> design: the <em>Model</em> stores the data; the <em>View</em> gets change notifications and displays the content of the model; the <em>Controller</em>, finally, changes the state of the model and notifies the view of these changes. For more information, and for a list of useful methods for TreeModel, see <link xref="model-view-controller.py"/>.
cs: Widget <code>TreeView</code> je vytvořen okolo návrhu <em>Model/Zobrazení/Ovládání</em>: <em>Model</em> uchovává data, <em>Zobrazení</em> dodává upozornění na změny a zobrazuje obsah modelu a konečně <em>Ovládání</em> mění stav modelu a upozorňuje zobrazení na tyto změny. Více informací a seznam použitelných metod pro <code>TreeModel</code> najdete v <link xref="model-view-controller.py"/>.

note: (itstool) path: section/p
en: In line 44 the <code>"changed"</code> signal is connected to the callback function <code>on_changed()</code> using <code><var>widget</var>.connect(<var>signal</var>, <var>callback function</var>)</code>. See <link xref="signals-callbacks.py"/> for a more detailed explanation.
cs: Na řádku 44 je signál <code>"changed"</code> napojen na funkci zpětného volání <code>on_changed()</code> pomocí <code><var>widget</var>.connect(<var>signál</var>, <var>funkce zpětného volání</var>)</code>. Podrobnější vysvětlení viz <link xref="signals-callbacks.py"/>.

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/pango/stable/pango-Fonts.html">Fonts</link>
cs: <link href="http://developer.gnome.org/pango/stable/pango-Fonts.html">Písma</link>

[ctx: text]
note: (itstool) path: info/title
en: Simple Treeview with ListStore (Vala)
cs: Jednoduchý Treeview s ListStore (Vala)

note: (itstool) path: info/desc
en: A widget can display any TreeModel implementation (lists and trees)
cs: Widget, který umí zobrazit libovolnou implementaci TreeModel (seznamy a stromy)

note: (itstool) path: page/title
en: Simple Treeview with ListStore
cs: Jednoduchý Treeview s ListStore

note: (itstool) path: page/p
en: This TreeView displays a simple ListStore with the Selection "changed" signal connected.
cs: Tento <code>TreeView</code> zobrazuje jednoduchý ListStore s napojeným signálem <code>"changed"</code> (změna výběru).

note: (itstool) path: page/code
en: public class PhoneBookEntry {
    	public string firstname;
    	public string lastname;
    	public string phone;
    
    	public PhoneBookEntry (string f, string l, string p) {
    		this.firstname = f;
    		this.lastname = l;
    		this.phone = p;
    	}
    }
    
    class TreeViewSimpleListStore : Gtk.ApplicationWindow {
    
    	Gtk.Label label;
    
    	PhoneBookEntry[] phonebook = {
    		new PhoneBookEntry ("Jurg", "Billeter", "555-0123"),
    		new PhoneBookEntry ("Johannes", "Schmid", "555-1234"),
    		new PhoneBookEntry ("Julita", "Inca", "555-2345"),
    		new PhoneBookEntry ("Javier", "Jardon", "555-3456"),
    		new PhoneBookEntry ("Jason", "Clinton", "555-4567"),
    		new PhoneBookEntry ("Random J.", "Hacker", "555-5678")
    	};
    
    	enum Column {
    		FIRSTNAME,
    		LASTNAME,
    		PHONE
    	}
    
    	internal TreeViewSimpleListStore (MyApplication app) {
    		Object (application: app, title: "My Phone Book");
    
    		this.set_default_size (250, 100);
    		this.border_width = 10;
    
    		var view = new Gtk.TreeView ();
    		this.setup_treeview (view);
    		view.expand = true;
    
    		label = new Gtk.Label ("");
    
    		var grid = new Gtk.Grid ();
    
    		grid.attach (view, 0, 0, 1, 1);
    		grid.attach (label, 0, 1, 1, 1);
    		this.add (grid);
    
    		var selection = view.get_selection ();
    		selection.changed.connect (this.on_changed);
    	}
    
    	void setup_treeview (Gtk.TreeView view) {
    		var listmodel = new Gtk.ListStore (3, typeof (string),
                                                  typeof (string),
                                                  typeof (string));
    		view.set_model (listmodel);
    
    		var cell = new Gtk.CellRendererText ();
    
    		/* 'weight' refers to font boldness.
    		 *  400 is normal.
    		 *  700 is bold.
    		 */
    		cell.set ("weight_set", true);
    		cell.set ("weight", 700);
    
    		/*columns*/
    		view.insert_column_with_attributes (-1, "First Name",
                                                    cell, "text",
                                                    Column.FIRSTNAME);
    
    		view.insert_column_with_attributes (-1, "Last Name",
                                                    new Gtk.CellRendererText (),
                                                    "text", Column.LASTNAME);
    
    		view.insert_column_with_attributes (-1, "Phone Number",
                                                    new Gtk.CellRendererText (),
                                                    "text", Column.PHONE);
    
    		/* Insert the phonebook into the ListStore */
    		Gtk.TreeIter iter;
    		for (int i = 0; i &lt; phonebook.length; i++) {
    			listmodel.append (out iter);
    			listmodel.set (iter, Column.FIRSTNAME,
                                     phonebook[i].firstname,
                                     Column.LASTNAME, phonebook[i].lastname,
                                     Column.PHONE, phonebook[i].phone);
    		}
    	}
    
    	void on_changed (Gtk.TreeSelection selection) {
    		Gtk.TreeModel model;
    		Gtk.TreeIter iter;
    		string name;
    		string lastname;
    		string phone;
    
    		if (selection.get_selected (out model, out iter)) {
    			model.get (iter,
                                       Column.FIRSTNAME, out name,
                                       Column.LASTNAME, out lastname,
                                       Column.PHONE, out phone);
    
    			label.set_text ("\n" + name + " " + lastname + " " + phone);
    		}
    	}
    }
    
    class MyApplication : Gtk.Application {
    	protected override void activate () {
    
    		/* Create new Window and show all the things. */
    		new TreeViewSimpleListStore (this).show_all ();
    	}
    
    	internal MyApplication () {
    		Object (application_id: "example.liststore.simple.treeview");
    	}
    }
    
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }
cs: public class PhoneBookEntry {
    	public string firstname;
    	public string lastname;
    	public string phone;
    
    	public PhoneBookEntry (string f, string l, string p) {
    		this.firstname = f;
    		this.lastname = l;
    		this.phone = p;
    	}
    }
    
    class TreeViewSimpleListStore : Gtk.ApplicationWindow {
    
    	Gtk.Label label;
    
    	PhoneBookEntry[] phonebook = {
    		new PhoneBookEntry ("Jurg", "Billeter", "555-0123"),
    		new PhoneBookEntry ("Johannes", "Schmid", "555-1234"),
    		new PhoneBookEntry ("Julita", "Inca", "555-2345"),
    		new PhoneBookEntry ("Javier", "Jardon", "555-3456"),
    		new PhoneBookEntry ("Jason", "Clinton", "555-4567"),
    		new PhoneBookEntry ("Random J.", "Hacker", "555-5678")
    	};
    
    	enum Column {
    		FIRSTNAME,
    		LASTNAME,
    		PHONE
    	}
    
    	internal TreeViewSimpleListStore (MyApplication app) {
    		Object (application: app, title: "My Phone Book");
    
    		this.set_default_size (250, 100);
    		this.border_width = 10;
    
    		var view = new Gtk.TreeView ();
    		this.setup_treeview (view);
    		view.expand = true;
    
    		label = new Gtk.Label ("");
    
    		var grid = new Gtk.Grid ();
    
    		grid.attach (view, 0, 0, 1, 1);
    		grid.attach (label, 0, 1, 1, 1);
    		this.add (grid);
    
    		var selection = view.get_selection ();
    		selection.changed.connect (this.on_changed);
    	}
    
    	void setup_treeview (Gtk.TreeView view) {
    		var listmodel = new Gtk.ListStore (3, typeof (string),
                                                  typeof (string),
                                                  typeof (string));
    		view.set_model (listmodel);
    
    		var cell = new Gtk.CellRendererText ();
    
    		/* "weight" označuje tučnost písma
    		 *  400 je normální
    		 *  700 je tučné
    		 */
    		cell.set ("weight_set", true);
    		cell.set ("weight", 700);
    
    		/* Sloupce */
    		view.insert_column_with_attributes (-1, "First Name",
                                                    cell, "text",
                                                    Column.FIRSTNAME);
    
    		view.insert_column_with_attributes (-1, "Last Name",
                                                    new Gtk.CellRendererText (),
                                                    "text", Column.LASTNAME);
    
    		view.insert_column_with_attributes (-1, "Phone Number",
                                                    new Gtk.CellRendererText (),
                                                    "text", Column.PHONE);
    
    		/* Vloží telefonní seznam do ListStore */
    		Gtk.TreeIter iter;
    		for (int i = 0; i &lt; phonebook.length; i++) {
    			listmodel.append (out iter);
    			listmodel.set (iter, Column.FIRSTNAME,
                                     phonebook[i].firstname,
                                     Column.LASTNAME, phonebook[i].lastname,
                                     Column.PHONE, phonebook[i].phone);
    		}
    	}
    
    	void on_changed (Gtk.TreeSelection selection) {
    		Gtk.TreeModel model;
    		Gtk.TreeIter iter;
    		string name;
    		string lastname;
    		string phone;
    
    		if (selection.get_selected (out model, out iter)) {
    			model.get (iter,
                                       Column.FIRSTNAME, out name,
                                       Column.LASTNAME, out lastname,
                                       Column.PHONE, out phone);
    
    			label.set_text ("\n" + name + " " + lastname + " " + phone);
    		}
    	}
    }
    
    class MyApplication : Gtk.Application {
    	protected override void activate () {
    
    		/* Vytvoří nové okno a vše v něm zobrazí */
    		new TreeViewSimpleListStore (this).show_all ();
    	}
    
    	internal MyApplication () {
    		Object (application_id: "example.liststore.simple.treeview");
    	}
    }
    
    int main (string[] args) {
    	return new MyApplication ().run (args);
    }

note: (itstool) path: info/desc
en: A TreeView displaying a TreeStore (simpler example)
cs: TreeView zobrazující TreeStore (jednodušší příklad)

note: (itstool) path: page/title
en: Simpler TreeView with TreeStore
cs: Jednoduchý TreeView s TreeStore

note: (itstool) path: page/p
en: This TreeView displays a TreeStore.
cs: Tento TreeView zobrazuje TreeStore.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import Pango
    import sys
    
    books = [["Tolstoy, Leo", "War and Peace", "Anna Karenina"],
             ["Shakespeare, William", "Hamlet", "Macbeth", "Othello"],
             ["Tolkien, J.R.R.", "The Lord of the Rings"]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Library", application=app)
            self.set_default_size(250, 100)
            self.set_border_width(10)
    
            # the data are stored in the model
            # create a treestore with one column
            store = Gtk.TreeStore(str)
            for i in range(len(books)):
                # the iter piter is returned when appending the author
                piter = store.append(None, [books[i][0]])
                # append the books as children of the author
                j = 1
                while j &lt; len(books[i]):
                    store.append(piter, [books[i][j]])
                    j += 1
    
            # the treeview shows the model
            # create a treeview on the model store
            view = Gtk.TreeView()
            view.set_model(store)
    
            # the cellrenderer for the column - text
            renderer_books = Gtk.CellRendererText()
            # the column is created
            column_books = Gtk.TreeViewColumn(
                "Books by Author", renderer_books, text=0)
            # and it is appended to the treeview
            view.append_column(column_books)
    
            # the books are sortable by author
            column_books.set_sort_column_id(0)
    
            # add the treeview to the window
            self.add(view)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import Pango
    import sys
    
    books = [["Tolstoy, Leo", "War and Peace", "Anna Karenina"],
             ["Shakespeare, William", "Hamlet", "Macbeth", "Othello"],
             ["Tolkien, J.R.R.", "The Lord of the Rings"]]
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Library", application=app)
            self.set_default_size(250, 100)
            self.set_border_width(10)
    
            # Data jsou uchována v modelu
            # Vytvoří TreeStore s jedním sloupcem
            store = Gtk.TreeStore(str)
            for i in range(len(books)):
                # Iterátor piter je vrácen, když je přidán autor
                piter = store.append(None, [books[i][0]])
                # Přidá knihu jako potomka k autorovi
                j = 1
                while j &lt; len(books[i]):
                    store.append(piter, [books[i][j]])
                    j += 1
    
            # TreeView zobrazuje model
            # Vytvoří TreeView založené na modelu
            view = Gtk.TreeView()
            view.set_model(store)
    
            # Vykreslovač pro sloupec - text
            renderer_books = Gtk.CellRendererText()
            # Vytvoří sloupec
            column_books = Gtk.TreeViewColumn(
                "Books by Author", renderer_books, text=0)
            # a přidá jej do TreeView
            view.append_column(column_books)
    
            # Knihy lze řadit podle autorů
            column_books.set_sort_column_id(0)
    
            # Přidá stromové zobrazení do okna
            self.add(view)
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

[ctx: text]
note: (itstool) path: info/title
en: Tutorial for beginners (Python)
cs: Výuka pro začátečníky (Python)

note: (itstool) path: info/desc
en: A tutorial for beginners who want to learn how to program GUIs using GTK+ in Python.
cs: Výuka pro začátečníky, kteří se chtějí naučit programovat GUI pomocí GTK+ v jazyce Python.

note: (itstool) path: credit/years
en: 2012 2013
cs: 2012, 2013

note: (itstool) path: synopsis/p
en: By following these tutorials you will learn the basics of GUI programming using GTK+ in Python.
cs: Když si projdete tyto lekce, naučíte se základy programování GUI pomocí GTK+ v jazyce Python.

note: (itstool) path: synopsis/p
en: If you have never programmed before, or are not familiar with the concepts of object oriented programming, you may need to learn a few basics first. The book <link href="http://learnpythonthehardway.org/book/">Learn Python the Hard Way</link> or <link href="http://docs.python.org/tutorial/index.html">The Python Tutorial</link> may be a better place for you to start. You may also be interested in <link href="http://python-gtk-3-tutorial.readthedocs.org/en/latest/index.html">The Python GTK+ 3 Tutorial</link>. Once you master the basics, be sure to come back and check out these tutorials.
cs: Pokud jste nikdy dříve neprogramovali, nebo nejste obeznámeni s konceptem objektově orientovaného programování, možná budete nejdříve potřebovat nějaké základy. Kniha <link href="http://learnpythonthehardway.org/book/">Naučte se Python náročným způsobem</link> nebo <link href="http://docs.python.org/tutorial/index.html">Výuka jazyka Python</link> mohou být dobrým vykročením. Zajímat by vás mohla také <link href="http://python-gtk-3-tutorial.readthedocs.org/en/latest/index.html">Výuka jazyka Python s GTK+ 3</link>. Jakmile zvládnete základy, nezapomeňte se vrátit sem a podívat se na tento výukový materiál.

note: (itstool) path: section/title
en: To run the code samples
cs: Spuštění kódu z ukázek

note: (itstool) path: section/p
en: To run the code samples in the tutorial:
cs: Když chcete spustit ukázkový kód z této lekce:

note: (itstool) path: item/p
en: Type or copy and paste the code into a file, and save the file with a name like <var>filename</var>.py
cs: Napište nebo zkopírujte a vložte kód do souboru a ten uložte s nějakým názvem, jako třeba <var>název_souboru</var>.py

note: (itstool) path: item/p
en: To execute the code, type in the terminal:
cs: Pro spuštění kódu napište v terminálu:

note: (itstool) path: item/screen
en: python <var>filename</var>.py
cs: python <var>název_souboru</var>.py

note: (itstool) path: section/p
en: After executing the code, you will either see the widget on your screen, or (if you have mistyped some of the code) you will see an error message that will help you identify the problem.
cs: Po spuštění kódu buď uvidíte widget na své obrazovce nebo (když jste v kódu něco špatně napsali) uvidíte chybové hlášení, které vám pomůže zjistit příčinu problému.

note: (itstool) path: section/title
en: A path through the widgets (with some theory)
cs: Procházka mezi widgety (s trochou teorie)

note: (itstool) path: section/p
en: The tutorial will walk you through increasingly complex examples and programming theory, but you can also feel free to just go directly to the tutorial that is most helpful to you.
cs: Lekce vás postupně provedou příklady a programátorskou teorií, od jednodušších věcí ke složitějším. Ale když budete chtít, můžete klidně skočit přímo na lekci, která vás zajímá.

note: (itstool) path: steps/title
en: Tutorial
cs: Lekce

note: (itstool) path: steps/title
en: Basic windows
cs: Základní okna

note: (itstool) path: steps/title
en: Images and labels
cs: Obrázky a popisky

note: (itstool) path: steps/title
en: Introduction to properties
cs: Úvod do vlastností

note: (itstool) path: steps/title
en: Grid, separator and scrolling
cs: Mřížka, oddělovač a posouvání

note: (itstool) path: steps/title
en: Signals, callbacks and buttons
cs: Signály, zpětná volání a tlačítka

note: (itstool) path: steps/title
en: Other display widgets
cs: Ostatní zobrazovací widgety

note: (itstool) path: steps/title
en: Entry widgets
cs: Vstupní widgety

note: (itstool) path: steps/title
en: A widget to write and display text
cs: Widget pro psaní a zobrazování textu

note: (itstool) path: steps/title
en: Dialogs
cs: Dialogová okna

note: (itstool) path: steps/title
en: Menus, Toolbars and Tooltips (also: using Glade and GtkBuilder)
cs: Nabídky, nástrojové lišty a vysvětlivky (také: používání Glade a GtkBuilder)

note: (itstool) path: steps/title
en: TreeViews and ComboBoxes (using the M/V/C design)
cs: Stromová zobrazení a rozbalovací seznamy (s návrhem Model/Zobrazení/Ovládání)

note: (itstool) path: steps/title
en: Custom widget
cs: Vlastní widget

note: (itstool) path: page/title
en: Tutorials, code samples and platform demos in Vala
cs: Výuka, ukázky kódu a demonstrace platformy v jazyce Vala

note: (itstool) path: section/title
en: Code samples and tutorial
cs: Ukázky kódu a výuka

[ctx: text]
note: (itstool) path: info/title
en: Weather application (JavaScript)
cs: Aplikace s počasím (JavaScript)

note: (itstool) path: info/desc
en: How to plan an application that uses asynchronous calls. Asynchronous calls will be presented through a weather application.
cs: Jak naplánovat aplikaci, která používá asynchronní volání. Asynchronní volání budou předvedena na aplikaci s počasím.

note: (itstool) path: page/title
en: Weather application
cs: Aplikace s počasím

note: (itstool) path: synopsis/p
en: In this guide well construct a weather application using asynchronous calls. Weather information in this example is fetched from geonames.org and the application is using the <link href="http://en.wikipedia.org/wiki/List_of_airports_by_ICAO_code:_E">ICAO codes </link> to place your weather request. To write and run all the code examples yourself, you need an editor to write code in, Terminal and GNOME 3 or higher installed into your computer. In this guide we we'll go through the following parts:
cs: V této lekci sestrojíme aplikaci s počasím používající asynchronní volání. Informace o počasí budeme v tomto příkladu získávat z geonames.org a aplikace používá <link href="http://cs.wikipedia.org/wiki/ICAO_k%C3%B3d_leti%C5%A1t%C4%9B">kódy ICAO</link> pro určení místa v požadavku o počasí. Abyste si mohli napsat a spustit kód příkladu sami, budete potřebovat v počítači nainstalovaný editor pro psaní kódu, terminál a GNOME 3.0 nebo novější. V této lekci budeme postupovat následujícími částmi:

note: (itstool) path: item/p
en: <link xref="#planningUi">Planning the graphical user interface</link>
cs: <link xref="#planningUi">Plánování grafického uživatelského rozhraní</link>

note: (itstool) path: item/p
en: <link xref="#asynchronous">Asynchronous calls</link>
cs: <link xref="#asynchronous">Asynchronní volání</link>

note: (itstool) path: item/p
en: <link xref="#main">The main program file</link>
cs: <link xref="#main">Soubor s hlavním programem</link>

note: (itstool) path: item/p
en: <link xref="#main">Local library GeoNames</link>
cs: <link xref="#main">Místní knihovna GeoNames</link>

note: (itstool) path: item/p
en: <link xref="#main">Autotools and Icons</link>
cs: <link xref="#main">Autotools a ikony</link>

note: (itstool) path: section/title
en: Planning the graphical user interface
cs: Plánování grafického uživatelského rozhraní

note: (itstool) path: section/p
en: Structuring an application for GNOME 3 means you will be using <link href="http://developer.gnome.org/platform-overview/stable/gtk">GTK+</link>. The most important thing is to remember that the main window will only accept one widget. You must plan your structure accordingly (this example is using Gtk.Grid). A useful method is to draw out the main window and place every widget needed inside that box. By looking at an image of your future application it is easier to tell what are the relations between widgets. For example Gtk.Grid places your widgets in relation to other widgets, so after the first widget is in place, placing widgets can be done in relation to any widget on the grid.
cs: Strukturování aplikace v GNOME 3 znamená používat <link href="http://developer.gnome.org/platform-overview/stable/gtk">GTK+</link>. Nejpodstatnější věc, kterou si musíte zapamatovat, je, že hlavní okno může obsahovat jen jeden widget. S tím musíte počítat při návrhu struktury (v tomto příkladu použijeme Gtk.Grid). Vhodným způsobem je vložit do hlavního okna tento box a všechny widgety umístit do něj. Když se podíváte na obrázek budoucí aplikace, je snadnější říci, jaké jsou mezi widgety vztahy. Například Gtk.Grid umisťuje vaše widgety vůči ostatním widgetům, takže od chvíle, kdy je na místě první widget, může být umístění dalších provedeno vůči ostatním widgetům v mřížce.

note: (itstool) path: section/title
en: Asynchronous calls
cs: Asynchronní volání

note: (itstool) path: section/p
en: With many programming languages, all operations are run synchronously - you tell the program to do something, and it will wait until that action completes before proceeding. This is however bad for graphical user interfaces, as then the whole application will be frozen while the program waits for the operation. Going asynchronous (async) helps here. With async calls, your UI won't be blocked with any requests. Async calls make your application more flexible and better equipped to handle situations when calls take more time than expected or for some reason get jammed. Async calls can be used for example file system I/O and for slower calculations in the background.
cs: V mnoha programovacích jazycích běží všechny operace synchronně – řeknete programu, aby něco udělal a než se může pokračovat, bude se čekat, než to bude úplně hotové. To se ale nehodí pro grafické uživatelské rozhraní, protože celá aplikaci by zamrzla během toho, co by se čekalo na nějakou operaci. Zde pomůže asynchronní provádění. S asynchronními voláními nebude vaše GUI blokováno žádným požadavkem. Asynchronní volání učiní vaši aplikaci pružnější a lépe vybavenou na zpracování situací, kdy volání zabralo více času, než se počítalo, nebo se z nějakého důvodu zaseklo. Asynchronní volání lze použít například u V/V operací souborového systému a pro pomalejší výpočty na pozadí.

note: (itstool) path: section/p
en: In this example we have to get data from geonames.org. While we do that we want the rest of our program to continue. If we wouldn't get any information from geonames.org for the lack of internet connection and this would be a synchronous application we would never get to the point where our main_quit() is processed correctly and the application would have to killed from Terminal.
cs: V tomto příkladu musíme získat data z geoname.org. Zatímco se tak bude dít, chceme aby zbytek programu pokračoval. Pokud bychom z geonames.org nedostali žádné informace kvůli problémům s připojením k Internetu a jednalo by se o synchronní aplikaci, nedostali bychom se nikdy do bodu, kdy je správně provedena naše funkce main_quit() a aplikaci by bylo nutné zabít z terminálu.

note: (itstool) path: section/title
en: The different parts of the program
cs: Různé části programu

note: (itstool) path: page/title
en: The main program file
cs: Soubor s hlavním programem

note: (itstool) path: synopsis/p
en: In this part of the guide well construct the main program file of the weather application. To write and run all the code examples yourself, you need an editor to write code in, Terminal and GNOME 3 or higher installed into your computer. In this part we we'll go through the following parts:
cs: V této části lekce sestavíme hlavní programový soubor aplikace s počasím. Abyste si mohli napsat a spustit kód příkladu sami, budete potřebovat v počítači nainstalovaný editor pro psaní kódu, terminál a GNOME 3.0 nebo novější. V této lekci budeme postupovat následujícími částmi:

note: (itstool) path: item/p
en: <link xref="#widgets">Adding a grid and all the necessary widgets to it</link>
cs: <link xref="#widgets">Přidání mřížky a všech potřebných widgetů do ní</link>

note: (itstool) path: item/p
en: <link xref="#asynccall">Requesting the weather information asynchronously</link>
cs: <link xref="#asynccall">Žádání o informace o počasí asynchronně</link>

note: (itstool) path: item/p
en: <link xref="#connectingbuttons">Connecting signals to button and entry</link>.
cs: <link xref="#connectingbuttons">Připojení signálů k tlačítkům a vstupním polím</link>

note: (itstool) path: section/p
en: This line tells how to run the script. It needs to be the first line of the code and it needs to be executable. To get the execution rights go to Terminal and run in right folder: chmod +x scriptname. Or you can use the graphical filemanager. Just go to the right folder where your code is, right click you code file, choose properties, click the permissions tab and check the box for allow executing file as a program
cs: Tento řádek říká, jak spustit skript. Musí být prvním řádek v souboru s kódem a soubor musí být spustitelný. Abyste získali práva na spuštění, jděte do terminálu a ve správné složce spusťte: chmod +x název_skriptu. Nebo můžete použít grafického správce souborů. Přejděte do správné složky s vašim kódem, klikněte na soubor s kódem pravým tlačítkem, zvolte vlastnosti, klikněte na kartu oprávnění a zaškrtněte políčko, které povoluje spuštění souboru jako programu.

note: (itstool) path: section/p
en: In order to have a working program we need to import a GObject Introspection -library to our use. For working UI, we need Gtk. Gtk is imported in the beginning so we have it in our use everywhere. We also import our own local JavaScript library geonames to our use here.
cs: Abychom získali funkční program, potřebujeme naimportovat GObject Introspection, což je knihovna, kterou využíváme. Pro funkční uživatelské rozhraní potřebujeme také Gtk. Gtk se importuje hned na začátku, takže jej můžeme použít kdekoliv. Importujeme také naši vlastní místní knihovnu geoname napsanou v jazyce JavaScript, protože ji zde využijeme.

note: (itstool) path: section/code
en: 
    // Initialize the gtk
    Gtk.init(null, 0);
    //create your window, name it and connect the x to quit function. Remember that window is a taken word
    var weatherwindow = new Gtk.Window({type: Gtk.WindowType.TOPLEVEL});
    weatherwindow.title = "Today's weather";
    //Window only accepts one widget and a title. Further structure with Gtk.boxes of similar
    weatherwindow.connect("destroy", function(){Gtk.main_quit()});
    
    weatherwindow.show_all();
    //and run it
    Gtk.main();
cs: 
    // Inicializuje GTK
    Gtk.init(null, 0);
    // Vytvoří okno, pojmenuje jej a napojí tlačítko „X“ na funkci pro ukončení
    // Pamatujte, že „window“ je rezervované slovo
    var weatherwindow = new Gtk.Window({type: Gtk.WindowType.TOPLEVEL});
    weatherwindow.title = "Today’s weather";
    // Okno přijímá jen jeden widget a název. Pro sloužitější struktury slouží Gtk.boxes apod.
    weatherwindow.connect("destroy", function(){Gtk.main_quit()});
    
    weatherwindow.show_all();
    // A spustí ji
    Gtk.main();

note: (itstool) path: section/title
en: Adding a grid and all the necessary widgets to it
cs: Přidání mřížky a všech potřebných widgetů do ní

note: (itstool) path: section/code
en: 
    var grid = new Gtk.Grid();
    weatherwindow.add(grid);
    
    //We initialize the icon here, but decide the file later in geonames.js.
    var weatherIcon = new Gtk.Image();
    
    //Set some labels to your window
    var label1 = new Gtk.Label({label: ""});
    var label2 = new Gtk.Label({label: "Looking in the sky..."});
    var label3 = new Gtk.Label({label: ""});
    
    var entry = new Gtk.Entry();
    entry.set_width_chars(4);
    entry.set_max_length(4);
    var label4 = new Gtk.Label({label: "Enter ICAO station for weather: "});
    var button1 = new Gtk.Button({label: "search!"});
    
    grid.attach(label4, 2, 1, 1, 1);
    grid.attach_next_to(label1,label4,3,1,1);
    grid.attach_next_to(label2,label1,3,1,1);
    grid.attach_next_to(label3,label2,3,1,1);
    grid.attach_next_to(entry,label4,1,1,1);
    grid.attach_next_to(button1,entry,1,1,1);
    grid.attach_next_to(weatherIcon,label2,1,1,1)
cs: 
    var grid = new Gtk.Grid();
    weatherwindow.add(grid);
    
    // Zde inicializujeme ikony, ale rozhodne se až později v geonames.js.
    var weatherIcon = new Gtk.Image();
    
    // Nastaví nějaké popisky do vašeho okna
    var label1 = new Gtk.Label({label: ""});
    var label2 = new Gtk.Label({label: "Looking in the sky..."});
    var label3 = new Gtk.Label({label: ""});
    
    var entry = new Gtk.Entry();
    entry.set_width_chars(4);
    entry.set_max_length(4);
    var label4 = new Gtk.Label({label: "Enter ICAO station for weather: "});
    var button1 = new Gtk.Button({label: "search!"});
    
    grid.attach(label4, 2, 1, 1, 1);
    grid.attach_next_to(label1,label4,3,1,1);
    grid.attach_next_to(label2,label1,3,1,1);
    grid.attach_next_to(label3,label2,3,1,1);
    grid.attach_next_to(entry,label4,1,1,1);
    grid.attach_next_to(button1,entry,1,1,1);
    grid.attach_next_to(weatherIcon,label2,1,1,1)

note: (itstool) path: section/p
en: In this section we create the grid we are going to use for positioning the widgets. All the buttons, labels and entries are initialized and placed on the grid. As seen from the placing of the different widgets, they don't need to be related only to one widget. At this point some of the labels don't have any content. The content for those widgets is applied later. If you run the application at this stage, you have the UI ready, but the widgets are not connected to anything. For this we need to first build the weather searching local library, and then get the information we need asynchronously. When we have our local library ready we can connect it to the necessary widgets.
cs: V této části vytvoříme mřížku, kterou se chystáme použít k umístění widgetů. Všechna tlačítka, popisky a vstupní pole jsou inicializována a umístěna v mřížce. Jak je vidět z umístění různých widgetů, nemusí se vztahovat jen k jednomu widgetu. V tuto chvíli nemají některé popisky žádný obsah. Ten bude doplněn později. Když aplikaci v této fázi spustíte, budete mít připravené uživatelské rozhraní, ale widgety nabudou nikam napojeny. Z tohoto důvodu potřebujeme nejprve sestavit místní knihovnu pro vyhledávání počasí a pak získávat informace, což chceme dělat asynchronně. Až budeme mít naši místní knihovnu připravenou, můžeme ji napojit na potřebné widgety.

note: (itstool) path: section/title
en: Requesting the weather information asynchronously
cs: Žádání o informace o počasí asynchroně

note: (itstool) path: section/code
en: 
    function getWeatherForStation() {
      var station = entry.get_text();
    
      var GeoNames = new WeatherService.GeoNames(station); //"EFHF";
    
      GeoNames.getWeather(function(error, weather) {
        //this here works bit like signals. This code will be run when we have weather.
        if (error) {
          label2.set_text("Suggested ICAO station does not exist Try EFHF");
        return; }
        weatherIcon.file = GeoNames.getIcon(weather);
    
        label1.set_text("Temperature is " + weather.weatherObservation.temperature + " degrees.");
        if (weather.weatherObservation.weatherCondition !== "n/a"){
          label2.set_text("Looks like there is " + weather.weatherObservation.weatherCondition + " in the sky.");
          }
        else {
          label2.set_text("Looks like there is " + weather.weatherObservation.clouds + " in the sky.");
        }
        label3.set_text("Windspeed is " + weather.weatherObservation.windSpeed + " m/s")
        // ...
      });
    }
cs: 
    function getWeatherForStation() {
      var station = entry.get_text();
    
      var GeoNames = new WeatherService.GeoNames(station); //"EFHF";
    
      GeoNames.getWeather(function(error, weather) {
        /* Toto funguje trochu jako signály. Tento kód bude spuštěn, kdykoliv budeme
           mít informaci o počasí. */
        if (error) {
          label2.set_text("Suggested ICAO station does not exist Try EFHF");
        return; }
        weatherIcon.file = GeoNames.getIcon(weather);
    
        label1.set_text("Temperature is " + weather.weatherObservation.temperature + " degrees.");
        if (weather.weatherObservation.weatherCondition !== "n/a"){
          label2.set_text("Looks like there is " + weather.weatherObservation.weatherCondition + " in the sky.");
          }
        else {
          label2.set_text("Looks like there is " + weather.weatherObservation.clouds + " in the sky.");
        }
        label3.set_text("Windspeed is " + weather.weatherObservation.windSpeed + " m/s")
        // ...
      });
    }

note: (itstool) path: section/p
en: This function is dedicated for calling for the weather information and updating labels and icons accordingly. In the beginning of the function we get the user input for the search. So here for the first time we use our own library and assign it to variable GeoNames. While assigning WeatherService we give it the station. The firs thing we do with GeoNames is to request weather. Everything after GeoNames.getWeather(function(error, weather) happens only if we either get an error message or weather information. If either doesn't come, the rest of the program works as normal, so main_Quit works.
cs: Tato funkce je určena k ptaní se na informace o počasí a k odpovídající aktualizaci popisků a ikon. Na začátku této funkce získáme vstup od uživatele udávající, na co se ptát. Takže zde konečně poprvé použijeme naši vlastní knihovnu a přiřadíme ji do proměnné <code>GeoNames</code>. Jakmile přiřadíme <code>WeatherService</code>, předáme ji obsluhu. První co uděláme v GeoNames, je dotaz na počasí. Vše, co se stane po <code>GeoNames.getWeather(function(error, weather)</code>, může být jen to, že dostaneme chybovou zprávu nebo informace o počasí. Pokud nic z toho nedorazí, bude zbytek programu normálně fungovat, včetně <code>main_Quit</code>.

note: (itstool) path: section/title
en: Connecting signals to button and entry.
cs: Připojení signálů k tlačítkům a vstupním polím

note: (itstool) path: section/code
en: 
    entry.connect("key_press_event", function(widget, event) {
      if (entry.get_text().length === 4) {
        // Enough is enough
        getWeatherForStation();
      }
      return false;
    });
    
    button1.connect("clicked", function(){
      getWeatherForStation();
    });
cs: 
    entry.connect("key_press_event", function(widget, event) {
      if (entry.get_text().length === 4) {
        // To už by stačilo
        getWeatherForStation();
      }
      return false;
    });
    
    button1.connect("clicked", function(){
      getWeatherForStation();
    });

note: (itstool) path: section/p
en: And finally we have the connections that make the whole application run as it should. We connect both the entry and the button to do the same thing, getting the weather. So it doesn't matter weather you press enter of click the search button.
cs: A nakonec zde máme propojení, která zajistí, že celá aplikace poběží jak má. Propojíme vstupní pole a tlačítko, aby dělali to stejné, získali informace o počasí. Nebude tak záležet na tom, jestli zmáčknete <key>Enter</key> nebo kliknete na tlačítko <gui>search</gui>.

note: (itstool) path: section/p
en: Weatherapp.js file looks like this:
cs: Soubor Weatherapp.js vypadá nějak takto:

note: (itstool) path: section/code
en: 
    #!/usr/bin/gjs
    //The previous line is a hash bang tells how to run the script.
    // Note that the script has to be executable (run in terminal in the right folder: chmod +x scriptname)
    
    var Gtk = imports.gi.Gtk;
    
    const WeatherService = imports.geonames;
    //Bring your own library from same folder (as set in GJS_PATH). If using autotools .desktop will take care of this
    
    // Initialize the gtk
    Gtk.init(null, 0);
    //create your window, name it and connect the x to quit function. Remember that window is a taken word
    var weatherwindow = new Gtk.Window({type: Gtk.WindowType.TOPLEVEL});
    weatherwindow.title = "Today's weather";
    //Window only accepts one widget and a title. Further structure with Gtk.boxes of similar
    weatherwindow.connect("destroy", function(){Gtk.main_quit()});
    //We initialize the icon here, but decide the file later in geonames.js.
    
    var weatherIcon = new Gtk.Image();
    
    //Set some labels to your window
    var label1 = new Gtk.Label({label: ""});
    var label2 = new Gtk.Label({label: "Looking in the sky..."});
    var label3 = new Gtk.Label({label: ""});
    
    var grid = new Gtk.Grid();
    weatherwindow.add(grid);
    
    var entry = new Gtk.Entry();
    entry.set_width_chars(4);
    entry.set_max_length(4);
    var label4 = new Gtk.Label({label: "Enter ICAO station for weather: "});
    var button1 = new Gtk.Button({label: "search!"});
    
    //some weather
    
    entry.connect("key_press_event", function(widget, event) {
      // FIXME: Get weather on enter (key 13)
      if (entry.get_text().length === 4) {
        // Enough is enough
        getWeatherForStation();
      }
      return false;
    });
    
    button1.connect("clicked", function(){
      getWeatherForStation();
    });
    
    function getWeatherForStation() {
      var station = entry.get_text();
    
      var GeoNames = new WeatherService.GeoNames(station); //"EFHF";
    
      GeoNames.getWeather(function(error, weather) {
        //this here works bit like signals. This code will be run when we have weather.
        if (error) {
          label2.set_text("Suggested ICAO station does not exist Try EFHF");
        return; }
        weatherIcon.file = GeoNames.getIcon(weather);
    
        label1.set_text("Temperature is " + weather.weatherObservation.temperature + " degrees.");
        if (weather.weatherObservation.weatherCondition !== "n/a"){
          label2.set_text("Looks like there is " + weather.weatherObservation.weatherCondition + " in the sky.");
          }
        else {
          label2.set_text("Looks like there is " + weather.weatherObservation.clouds + " in the sky.");
        }
        label3.set_text("Windspeed is " + weather.weatherObservation.windSpeed + " m/s")
        // ...
      });
    }
    
    grid.attach(label4, 2, 1, 1, 1);
    grid.attach_next_to(label1,label4,3,1,1);
    grid.attach_next_to(label2,label1,3,1,1);
    grid.attach_next_to(label3,label2,3,1,1);
    grid.attach_next_to(entry,label4,1,1,1);
    grid.attach_next_to(button1,entry,1,1,1);
    grid.attach_next_to(weatherIcon,label2,1,1,1)
    weatherwindow.show_all();
    //and run it
    Gtk.main();
cs: 
    #!/usr/bin/gjs
    // Předchozí řádek je tzv. "hash bang", který říká, jak skript spustit
    // Upozorňujeme, že skript musí být spustitelný
    // (v terminálu ve správné složce proveďte: chmod +x název_skriptu)
    
    var Gtk = imports.gi.Gtk;
    
    const WeatherService = imports.geonames;
    // Připraví vaši vlastní knihovnu ze stejné složky (nastaveno v GJS_PATH)
    // Pokud používáte autotools, .desktop se o to postará
    
    // Inicializuje GTK
    Gtk.init(null, 0);
    // Vytvoří okno, pojmenuje jej a napojí tlačítko „X“ na funkci pro ukončení
    // Pamatujte, že „window“ je rezervované slovo
    var weatherwindow = new Gtk.Window({type: Gtk.WindowType.TOPLEVEL});
    weatherwindow.title = "Today’s weather";
    // Okno přijímá jen jeden widget a název. Pro sloužitější struktury slouží Gtk.boxes apod.
    weatherwindow.connect("destroy", function(){Gtk.main_quit()});
    // Zde inicializujeme ikony, ale rozhodne se až později v geonames.js.
    
    var weatherIcon = new Gtk.Image();
    
    // Nastaví nějaké popisky do vašeho okna
    var label1 = new Gtk.Label({label: ""});
    var label2 = new Gtk.Label({label: "Looking in the sky..."});
    var label3 = new Gtk.Label({label: ""});
    
    var grid = new Gtk.Grid();
    weatherwindow.add(grid);
    
    var entry = new Gtk.Entry();
    entry.set_width_chars(4);
    entry.set_max_length(4);
    var label4 = new Gtk.Label({label: "Enter ICAO station for weather: "});
    var button1 = new Gtk.Button({label: "search!"});
    
    // Nějaké počasí
    
    entry.connect("key_press_event", function(widget, event) {
      // FIXME: Získat počasí klávesou Enter (key 13)
      if (entry.get_text().length === 4) {
        // To už by stačilo
        getWeatherForStation();
      }
      return false;
    });
    
    button1.connect("clicked", function(){
      getWeatherForStation();
    });
    
    function getWeatherForStation() {
      var station = entry.get_text();
    
      var GeoNames = new WeatherService.GeoNames(station); //"EFHF";
    
      GeoNames.getWeather(function(error, weather) {
        // Toto funguje trochu jako signály. Tento kód bude spuštěn, kdykoliv budeme mít informaci o počasí
        if (error) {
          label2.set_text("Suggested ICAO station does not exist Try EFHF");
        return; }
        weatherIcon.file = GeoNames.getIcon(weather);
    
        label1.set_text("Temperature is " + weather.weatherObservation.temperature + " degrees.");
        if (weather.weatherObservation.weatherCondition !== "n/a"){
          label2.set_text("Looks like there is " + weather.weatherObservation.weatherCondition + " in the sky.");
          }
        else {
          label2.set_text("Looks like there is " + weather.weatherObservation.clouds + " in the sky.");
        }
        label3.set_text("Windspeed is " + weather.weatherObservation.windSpeed + " m/s")
        // ...
      });
    }
    
    grid.attach(label4, 2, 1, 1, 1);
    grid.attach_next_to(label1,label4,3,1,1);
    grid.attach_next_to(label2,label1,3,1,1);
    grid.attach_next_to(label3,label2,3,1,1);
    grid.attach_next_to(entry,label4,1,1,1);
    grid.attach_next_to(button1,entry,1,1,1);
    grid.attach_next_to(weatherIcon,label2,1,1,1)
    weatherwindow.show_all();
    // A spustí ji
    Gtk.main();

note: (itstool) path: section/p
en: Running until you have all the autotools files ready. :
cs: Nechte běžet, dokud nebudou připravené všechny soubory autotools:

note: (itstool) path: section/p
en: Use this command on terminal while developing your modules. When calling your program in this manner it knows where to find your custom JSlibraries, in this case geonames.js.
cs: Tento příkaz použijte v terminálu při vývoji svých modulů. Když zavoláte svůj program tímto způsobem, bude vědět, kde má hledat vaše vlastí knihovny v jazyce JavaScript, v tomto případě geonames.js.

note: (itstool) path: page/title
en: Autotools and Icons
cs: Autotools a ikony

note: (itstool) path: synopsis/p
en: In this part of the guide well construct the autotools and custom icons needed for weather application to be a seamless part of your desktop. To write and run all the code examples yourself, you need an editor to write code in, Terminal and GNOME 3 or higher installed into your computer. In this guide we we'll go through the following parts:
cs: V této části lekce sestrojíme soubory pro autotools a vlastní ikony, které budeme potřebovat pro aplikaci s počasím, aby perfektně zapadla do pracovního prostředí. Abyste si mohli napsat a spustit kód příkladu sami, budete potřebovat v počítači nainstalovaný editor pro psaní kódu, terminál a GNOME 3.0 nebo novější. V této lekci budeme postupovat následujícími částmi:

note: (itstool) path: item/p
en: <link xref="#autotools"> Autotools</link>
cs: <link xref="#autotools">Autotools</link>

note: (itstool) path: item/p
en: <link xref="#icons">Custom icons for your application</link>
cs: <link xref="#icons">Vlastní ikony pro vaši aplikaci</link>

note: (itstool) path: section/title
en: Autotools and necessary files
cs: Autotools a nutné soubory

note: (itstool) path: section/p
en: Having more than one file in your folder makes using autotools a bit tricky. You need the .desktop file, autogen.sh, Makefile.am, configure.ac and as a new file: myapp.sh.in file. Hacking the autotools file is a complicated field. More information can be found in many different sources, <link href="http://en.wikipedia.org/wiki/GNU_build_system">the Wikipedia article</link> provides a good overview on the subject.
cs: To, že máté ve své složce více než jeden soubor, trochu komplikuje použití autotools. Potřebujete soubor .desktop, autogen.sh, Makefile.am, configure.as a nově soubor myapp.sh.in. Uprava souborů autotools je složitá záležitost. Více informací můžete najít v různých zdrojích, dobrý přehled na dané téma je v <link href="http://en.wikipedia.org/wiki/GNU_build_system">článku na Wikipedii</link>.

note: (itstool) path: section/p
en: The thing to notice in this file is that the Exec line will make this .desktop file work only after running all the other makefiles. Weatherapp.sh is a small shell script created with the weatherapp.sh.in.
cs: Věc, která v tomto souboru stojí za pozornost, je, že řádek <code>Exec</code> bude v tomto souboru .desktop funkční až teprve po proběhnutí všech ostatních souboru <file>Makefile</file>. Soubor <file>weatherapp.sh</file> je malý shellový skript vytvořený z <file>weatherapp.sh.in</file>.

note: (itstool) path: section/p
en: This file is a template to the file Makefile will do to be run from .desktop.
cs: Tento soubor je šablonou, podle které Makefile udělá soubor <file>.desktop</file> pro spouštění aplikace.

note: (itstool) path: section/code
en: 
    # The actual runnable program is set to the SCRIPTS primitive. Prefix bin_ tells where to copy this
    bin_SCRIPTS = weatherapp.js geonames.js weatherapp.sh
    # List of files to be distributed
    EXTRA_DIST=  \
        $(bin_SCRIPTS) \
        $(private_icons)	\
    	  $(NULL)
    
    CLEANFILES =
    
    # The desktop files
    desktopdir = $(datadir)/applications
    desktop_DATA =weatherapp.desktop
    
    # convenience command for doing Makefile variable substitutions in non-Makefile
    # files (scripts, service files, etc.)
    do_subst = sed -e 's|@abs_top_srcdir[@]|$(abs_top_srcdir)|g' \
                   -e 's|@abs_top_builddir[@]|$(abs_top_builddir)|g' \
                   -e 's|@localedir[@]|$(localedir)|g' \
                   -e 's|@bindir[@]|$(bindir)|g' \
                   -e 's|@libexecdir[@]|$(libexecdir)|g' \
    	       -e 's|@pkglibdir[@]|$(pkglibdir)|g' \
    	       -e 's|@pkgdatadir[@]|$(pkgdatadir)|g' \
    	       -e 's|@have_libnotify[@]|$(HAVE_LIBNOTIFY)|g' \
    	       -e 's|@have_libsoup[@]|$(HAVE_LIBSOUP)|g' \
    	       -e 's|@have_cheese[@]|$(HAVE_CHEESE)|g'
    
    weatherapp.sh: weatherapp.sh.in
    	$(AM_V_GEN) $(do_subst) $&lt; &gt; $@
    	chmod +x $@
    
    CLEANFILES += weatherapp.sh
    EXTRA_DIST += weatherapp.sh.in
    
    #the application icon
    appicondir=$(datadir)/icons/hicolor/scalable/apps
    appicon_DATA=weather-icon.svg
    
    #icons in the application
    NULL =
    
    private_icons = \
    	weather-clear.svg \
      weather-few-clouds.svg \
      weather-fog.svg \
      weather-icon.svg \
      weather-overcast.svg \
      weather-showers.svg \
      weather-showers-scattered.svg \
      weather-snow.svg \
      $(NULL)
    
    install-icons:
    	for icon in $(private_icons); do \
    		mkdir -p $(DESTDIR)$(pkgdatadir)/icons/; \
    		$(INSTALL_DATA) $(srcdir)/$$icon $(DESTDIR)$(pkgdatadir)/icons/; \
    	done
    
    install-data-local: install-icons
cs: 
    # Skutečný spustitelný program je nastaven do primitiva SCRIPTS
    # Prefix bin_ říká, kam to nakopírovat
    bin_SCRIPTS = weatherapp.js geonames.js weatherapp.sh
    # Seznam souborů, které se mají šířit
    EXTRA_DIST=  \
        $(bin_SCRIPTS) \
        $(private_icons)	\
    	  $(NULL)
    
    CLEANFILES =
    
    # Soubory .desktop
    desktopdir = $(datadir)/applications
    desktop_DATA =weatherapp.desktop
    
    # Užitečný příkaz provádějící substituce proměnných Makefile v jiných souborech
    # než Makefile (skriptech, souborech service atd.)
    do_subst = sed -e 's|@abs_top_srcdir[@]|$(abs_top_srcdir)|g' \
                   -e 's|@abs_top_builddir[@]|$(abs_top_builddir)|g' \
                   -e 's|@localedir[@]|$(localedir)|g' \
                   -e 's|@bindir[@]|$(bindir)|g' \
                   -e 's|@libexecdir[@]|$(libexecdir)|g' \
    	       -e 's|@pkglibdir[@]|$(pkglibdir)|g' \
    	       -e 's|@pkgdatadir[@]|$(pkgdatadir)|g' \
    	       -e 's|@have_libnotify[@]|$(HAVE_LIBNOTIFY)|g' \
    	       -e 's|@have_libsoup[@]|$(HAVE_LIBSOUP)|g' \
    	       -e 's|@have_cheese[@]|$(HAVE_CHEESE)|g'
    
    weatherapp.sh: weatherapp.sh.in
    	$(AM_V_GEN) $(do_subst) $&lt; &gt; $@
    	chmod +x $@
    
    CLEANFILES += weatherapp.sh
    EXTRA_DIST += weatherapp.sh.in
    
    # Ikona aplikace
    appicondir=$(datadir)/icons/hicolor/scalable/apps
    appicon_DATA=weather-icon.svg
    
    # Ikony v aplikaci
    NULL =
    
    private_icons = \
    	weather-clear.svg \
      weather-few-clouds.svg \
      weather-fog.svg \
      weather-icon.svg \
      weather-overcast.svg \
      weather-showers.svg \
      weather-showers-scattered.svg \
      weather-snow.svg \
      $(NULL)
    
    install-icons:
    	for icon in $(private_icons); do \
    		mkdir -p $(DESTDIR)$(pkgdatadir)/icons/; \
    		$(INSTALL_DATA) $(srcdir)/$$icon $(DESTDIR)$(pkgdatadir)/icons/; \
    	done
    
    install-data-local: install-icons

note: (itstool) path: section/p
en: This needs a bit more explaining. Compared to the HelloWorld Makefile.am this has changed quite a bit. Lets go through all the new blocks:
cs: Toto potřebuje lehké vysvětlení. V porovnání s <file>Makefile.am</file> z HelloWorld zde došlo k drobným změnám. Pojďme se podívat na všechny nové části:

note: (itstool) path: section/p
en: bin_scripts are the files that are needed to run your application. In thin case they are the first two files are the program itself and the third is the script that launches the application.
cs: <code>bin_scripts</code> jsou soubory, které jsou zapotřebí k běhu aplikace. V tomto případě jsou první dva soubory vlastní program a třetí soubor je skript, který aplikací spouští.

note: (itstool) path: section/p
en: EXTRA_DIST are the files that are to be distributed
cs: <code>EXTRA_DIST</code> jsou soubory, které budou šířeny.

note: (itstool) path: section/p
en: do_subst block is bits and pieces that need to be where they are
cs: Blok <code>do_subst</code> jsou drobnosti, které ale musí být tam, kde jsou.

note: (itstool) path: section/p
en: after the comment #icons in the application there are all the icons that are used by the program. For them to be useful you need to install the icons in correct places and that is done by the install-icons: bit
cs: Za komentářem <code># Ikony v aplikaci</code> jsou všechny ikony, které používáme v programu. Aby byly použitelné, je potřeba je nainstalovat na správná místa a to zařídí <code>install-icons</code>.

note: (itstool) path: section/code
en: 
    #!/bin/sh
    # This will run autoconf, automake, etc. for us
    autoreconf --force --install
cs: 
    #!/bin/sh
    # Toto nám spustí autoconf, automake, atd.
    autoreconf --force --install

note: (itstool) path: section/title
en: Custom icons for your application
cs: Vlastní ikony pro vaši aplikaci

note: (itstool) path: section/p
en: When thinking about custom icons a good rule of thumb is: do you expect to see that icon used elsewhere or is it private to your app? If the first (e.g. the icons in the desktop file that are shown by the shell) then you need /usr/share/hicolor, otherwise (e.g. the weather icons of your app) /usr/share/$application/bla/bla
cs: Pokud uvažujete o vlastních ikonách, je dobré pravidlo: očekáváte, že uvidíte tuto ikono použitou i někde jinde, nebo je výhradně pro vaši aplikaci? V prvním případě (např. ikony v souboru .desktop zobrazuje shell) potřebujete <file>/usr/share/hicolor</file>, v opačném (např. ikony počasí ve vaší aplikaci) <file>/usr/share/$application/bla/bla</file>.

note: (itstool) path: section/p
en: Using autotools you have to make some changes to your .desktop and Makefile.am files. In the desktop file you change the Icon's name Icon=weather-icon. In the Makefile.am file you add these two lines to the end of your application #the application icon
cs: Pokud používáte autotools, budete muset provést některé změny ve svých souborech .desktop a Makefile.am. V souboru .desktop změňte název ikony na <code>Icon=weather-icon</code>. V souboru <file>Makefile.am</file> přidejte tyto dva řádky na konec vašeho bloku <code># Ikona aplikace</code>.

note: (itstool) path: page/title
en: Local library geoNames
cs: Místní knihovna geoNames

note: (itstool) path: synopsis/p
en: In this part of the guide we'll construct the local library geoNames using asynchronous calls. Weather information in this example is fetched from geonames.org and the application is using the <link href="http://en.wikipedia.org/wiki/List_of_airports_by_ICAO_code:_E">ICAO codes </link> to place your weather request. To write and run all the code examples yourself, you need an editor to write code in, Terminal and GNOME 3 or higher installed into your computer. In this guide we'll go through the following parts:
cs: V této část lekce sestrojíme místní knihovnu geoNames používající asynchronní volání. Informace o počasí budeme v tomto příkladu získávat z geonames.org a aplikace používá <link href="http://cs.wikipedia.org/wiki/ICAO_k%C3%B3d_leti%C5%A1t%C4%9B">kódy ICAO</link> pro určení místa v požadavku o počasí. Abyste si mohli napsat a spustit kód příkladu sami, budete potřebovat v počítači nainstalovaný editor pro psaní kódu, terminál a GNOME 3.0 nebo novější. V této lekci budeme postupovat následujícími částmi:

note: (itstool) path: item/p
en: <link xref="#geonamesimports">Local library for getting the weather</link>
cs: <link xref="#geonamesimports">Místní knihovna pro získávání počasí</link>

note: (itstool) path: item/p
en: <link xref="#geonamesfunction">Creating function geoNames</link>
cs: <link xref="#geonamesfunction">Vytvoření funkce GeoNames</link>

note: (itstool) path: item/p
en: <link xref="#geonamesmethods">Methods for geoNames</link>
cs: <link xref="#geonamesmethods">Metody pro GeoNames</link>

note: (itstool) path: section/title
en: Local library for getting the weather
cs: Místní knihovna pro získávání počasí

note: (itstool) path: section/p
en: For this we need a new file that will be our local library.
cs: K tomu potřebujeme nový soubor, který bude naší místní knihovnou.

note: (itstool) path: section/p
en: In the first lines we'll import and initialize the libraries we need to use in this local library. Soup handles all the requests we have to make with http.
cs: Na prvních řádcích naimportujeme a inicializujeme knihovny, které potřebujeme použít v této místní knihovně. Knihovna Soup zpracovává všechny požadavky, které musíme dělat přes HTTP.

note: (itstool) path: section/title
en: Creating function GeoNames
cs: Vytvoření funkce GeoNames

note: (itstool) path: section/p
en: Here we create the function GeoNames that will handle getting weather for us. JavaScript allows us to create functions that have little inside at first and later expand them. This will be done inside the GeoNames.prototype curly braces{}
cs: Zde vytvoříme funkci GeoNames, která se nám bude starat o získávání počasí. JavaScript umožňuje vytvořit funkce, které na začátku mají v těle jen základ, který později rozšíříme. Provádíme to mezi složenými závorkami u GeoNames.prototype.

note: (itstool) path: section/title
en: Methods for GeoNames
cs: Metody pro GeoNames

note: (itstool) path: section/p
en: The first method for GeoNames is getWeather and the second getIcon. In getWeather we make a http request with soup, handle errors and then parse the information from the request to form we can use it. In getIcon we simply compare the results we got from getWeather to the switch we have in order to get the icon matching current weather. Now that we have our local library ready, it's time to make use of it.
cs: První metodou pro GeoName je <code>getWeather</code> a druhou <code>getIcon</code>. V <code>getWeather</code> vytvoříme pomocí knihovny soup požadavek http, obsloužíme chyby a zpracujeme informace z odpovědi do formy, kterou chceme používat. V <code>getIcon</code> jednoduše porovnáme výsledky, které jsem dostali od předchozí funkce a podle nich ve výrazu <code>switch</code> získáme ikonu odpovídající aktuálnímu počasí. Nyní, když máme naši místní knihovnu připravenou, je načase ji použít.

note: (itstool) path: section/p
en: Here is the entire code for our local library. The main program file calls this asynchronously.
cs: Zde je celý kód pro naši místní knihovnu. Soubor s hlavním programem ji volá asynchronně.

note: (itstool) path: info/desc
en: A widget that uses the Cairo library to draw
cs: Widget, který používá k vykreslování knihovnu Cairo.

note: (itstool) path: page/p
en: Enter an angle, visualize it.
cs: Zadejte úhel a on se zhmotní.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    from gi.repository import cairo
    import sys
    import math
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Choose an angle", application=app)
            self.set_default_size(400, 400)
            self.set_border_width(10)
    
            # a default angle
            self.angle = 360
    
            grid = Gtk.Grid()
    
            # a spinbutton that takes the value of an angle
            ad = Gtk.Adjustment(360, 0, 360, 1, 0, 0)
            self.spin = Gtk.SpinButton(adjustment=ad, climb_rate=1, digits=0)
            self.spin.connect("value-changed", self.get_angle)
    
            # a drawing area for drawing whatever we want
            self.darea = Gtk.DrawingArea()
            # that we describe in the method draw(), connected to the signal "draw"
            self.darea.connect("draw", self.draw)
            # we have to request a minimum size of the drawing area, or it will
            # disappear
            self.darea.set_size_request(300, 300)
    
            grid.attach(self.spin, 0, 0, 1, 1)
            grid.attach(self.darea, 0, 1, 1, 1)
    
            self.add(grid)
    
        # whenever we get a new angle in the spinbutton
        def get_angle(self, event):
            self.angle = self.spin.get_value_as_int()
            # redraw what is in the drawing area
            self.darea.queue_draw()
    
        def draw(self, darea, cr):
            # a 10-pixels-wide line
            cr.set_line_width(10)
            # red
            cr.set_source_rgba(0.5, 0.0, 0.0, 1.0)
    
            # get the width and height of the drawing area
            w = self.darea.get_allocated_width()
            h = self.darea.get_allocated_height()
    
            # move to the center of the drawing area
            # (translate from the top left corner to w/2, h/2)
            cr.translate(w / 2, h / 2)
            # draw a line to (55, 0)
            cr.line_to(55, 0)
            # and get back to (0, 0)
            cr.line_to(0, 0)
            # draw an arc centered in the origin, 50 pixels wide, from the angle 0
            # (in radians) to the angle given by the spinbutton (in degrees)
            cr.arc(0, 0, 50, 0, self.angle * (math.pi / 180))
            # draw a line back to the origin
            cr.line_to(0, 0)
            # drawing the path, and keeping the path for future use
            cr.stroke_preserve()
    
            # set a colour
            cr.set_source_rgba(0.0, 0.5, 0.5, 1.0)
            # and use it to fill the path (that we had kept)
            cr.fill()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    from gi.repository import cairo
    import sys
    import math
    
    
    class MyWindow(Gtk.ApplicationWindow):
    
        def __init__(self, app):
            Gtk.Window.__init__(self, title="Choose an angle", application=app)
            self.set_default_size(400, 400)
            self.set_border_width(10)
    
            # Výchozí úhel
            self.angle = 360
    
            grid = Gtk.Grid()
    
            # Číselník, který získává hodnotu úhlu
            ad = Gtk.Adjustment(360, 0, 360, 1, 0, 0)
            self.spin = Gtk.SpinButton(adjustment=ad, climb_rate=1, digits=0)
            self.spin.connect("value-changed", self.get_angle)
    
            # Kreslicí oblast pro kreslení čehokoliv chcete
            self.darea = Gtk.DrawingArea()
            # co jsme popsali v metodě draw() napojené na signál "draw"
            self.darea.connect("draw", self.draw)
            # Musí požádat o minimální velikost kreslicí oblasti, jinak ta
            # zmizí
            self.darea.set_size_request(300, 300)
    
            grid.attach(self.spin, 0, 0, 1, 1)
            grid.attach(self.darea, 0, 1, 1, 1)
    
            self.add(grid)
    
        # whenever we get a new angle in the spinbutton
        def get_angle(self, event):
            self.angle = self.spin.get_value_as_int()
            # Překreslí to, co je v kreslicí oblasti
            self.darea.queue_draw()
    
        def draw(self, darea, cr):
            # Čára tlustá 10 pixelů
            cr.set_line_width(10)
            # Červená
            cr.set_source_rgba(0.5, 0.0, 0.0, 1.0)
    
            # Získá šířku a výšku kreslicí oblasti
            w = self.darea.get_allocated_width()
            h = self.darea.get_allocated_height()
    
            # Posune počátek se do středu kreslicí oblasti
            # (z levého horního rohu na šířka/2, výška/2)
            cr.translate(w / 2, h / 2)
            # Nakreslí čáru do (55, 0)
            cr.line_to(55, 0)
            # a zpátky do (0, 0)
            cr.line_to(0, 0)
            # Nakreslí oblouk se středem v počátku, 50 pixelů široký, od úhlu 0
            # (v radiánech) do úhlu daného hodnotou v číselníku (ve stupních)
            cr.arc(0, 0, 50, 0, self.angle * (math.pi / 180))
            # Nakreslí čáru zpět do počátku
            cr.line_to(0, 0)
            # Vykreslí cestu a ponechá ji pro pozdější použití
            cr.stroke_preserve()
    
            # Nastaví barvu
            cr.set_source_rgba(0.0, 0.5, 0.5, 1.0)
            # a použije ji k vyplnění cesty (kterou jsme si ponechali)
            cr.fill()
    
    
    class MyApplication(Gtk.Application):
    
        def __init__(self):
            Gtk.Application.__init__(self)
    
        def do_activate(self):
            win = MyWindow(self)
            win.show_all()
    
        def do_startup(self):
            Gtk.Application.do_startup(self)
    
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: item/p
en: <link href="http://www.tortall.net/mu/wiki/CairoTutorial">The Cairo Tutorial for Python Programmers</link>
cs: <link href="http://www.tortall.net/mu/wiki/CairoTutorial">Výuka Cairo pro programátory v jazyce Python</link>

note: (itstool) path: info/desc
en: A toplevel window which can contain other widgets
cs: Okno nejvyšší úrovně, které může obsahovat další widgety

note: (itstool) path: page/p
en: A minimal GtkApplication. Use <link xref="GtkApplicationWindow.c">Application Window</link> if you need GMenu support.
cs: Nejjednodušší GtkApplication. Pokud potřebujete podporu GMenu, použijte <link xref="GtkApplicationWindow.c">Aplikační okno</link>.

note: (itstool) path: info/desc
en: A basic window which can contain other widgets
cs: Základní okno, které může obsahovat ostatní widgety

note: (itstool) path: td/p
en: A minimal GtkApplication
cs: Minimální GtkApplication

note: (itstool) path: td/p
en: Use <link xref="GtkApplicationWindow.js">ApplicationWindow</link> if you need GMenu support.
cs: Pokud potřebujete podporu GMenu, použijte <link xref="GtkApplicationWindow.js">Aplikační okno</link>.

note: (itstool) path: page/code
en: 
    #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class Application {
        //create the application
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.myapp',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
           this.application.connect('activate', this._onActivate.bind(this));
        }
    
        //callback function for 'activate' signal
        _onActivate() {
            let myWindow = new Gtk.Window({type: Gtk.WindowType.TOPLEVEL});
            myWindow.title = "Welcome to GNOME";
    
           /* Here are a few ways we can customize our window.
           Try uncommenting them or changing their values! */
            //myWindow.set_default_size (400,200);
            //myWindow.set_has_resize_grip (false);
            //myWindow.set_opacity (0.5);
            //myWindow.maximize ();
    
            //show the window and all child widgets (none in this case)
            myWindow.show_all();
            this.application.add_window(myWindow);
        }
    };
    
    //run the application
    let app = new Application ();
    app.application.run (ARGV);
cs: 
    #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    
    const Gio = imports.gi.Gio;
    const GLib = imports.gi.GLib;
    const Gtk = imports.gi.Gtk;
    
    class Application {
        // Vytvoří aplikaci
        constructor() {
        constructor() {
            this.application = new Gtk.Application({
                application_id: 'org.example.myapp',
                flags: Gio.ApplicationFlags.FLAGS_NONE
            });
    
           this.application.connect('activate', this._onActivate.bind(this));
        }
    
        // Funkce zpětného volání pro signál "activate"
        _onActivate() {
            let myWindow = new Gtk.Window({type: Gtk.WindowType.TOPLEVEL});
            myWindow.title = "Welcome to GNOME";
    
           /* Zde je pár způsobů, jak si okno přizpůsobit.
              Zkuste zrušit jeji zakomentování a jejich hodnoty! */
            //myWindow.set_default_size (400,200);
            //myWindow.set_has_resize_grip (false);
            //myWindow.set_opacity (0.5);
            //myWindow.maximize ();
    
            // Zobrazí okno a všechny jeho synovské widgety (v tomto případě žádné)
            myWindow.show_all();
            this.application.add_window(myWindow);
        }
    };
    
    // Spustí aplikaci
    let app = new Application ();
    app.application.run (ARGV);

note: (itstool) path: page/p
en: In this example we used the following:
cs: V tomto příkladu se používá následující:

note: (itstool) path: td/p
en: A minimal GTK+ Application: a window with a title.
cs: Minimální aplikace GTK+: okno se záhlavím.

note: (itstool) path: td/p
en: Use <link xref="GtkApplicationWindow.py"/> if you need <link xref="gmenu.py"/> support.
cs: Pokud potřebujete podporu <link xref="gmenu.py"/>, použijte <link xref="GtkApplicationWindow.py"/>.

note: (itstool) path: section/code
en: from gi.repository import Gtk
    import sys
    
    
    class MyApplication(Gtk.Application):
    
        def do_activate(self):
            # create a Gtk Window belonging to the application itself
            window = Gtk.Window(application=self)
            # set the title
            window.set_title("Welcome to GNOME")
            # show the window
            window.show_all()
    
    # create and run the application, exit with the value returned by
    # running the program
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)
cs: from gi.repository import Gtk
    import sys
    
    
    class MyApplication(Gtk.Application):
    
        def do_activate(self):
            # Vytvoří okno Gtk Window patřící vlastní aplikaci
            window = Gtk.Window(application=self)
            # Nastaví název pro záhlaví
            window.set_title("Welcome to GNOME")
            # Zobrazí okno
            window.show_all()
    
    # Vytvoří a spustí aplikaci; skončí s návratovou hodnotou vrácenou
    # běžícím programem
    app = MyApplication()
    exit_status = app.run(sys.argv)
    sys.exit(exit_status)

note: (itstool) path: section/title
en: Useful methods for a Window widget
cs: Užitečné metody pro widget Window

note: (itstool) path: td/p
en: The simplest Gtk.Application
cs: Nejjednodušší Gtk.Application

note: (itstool) path: td/p
en: Use <link xref="GtkApplicationWindow.vala">Application Window</link> if you need GMenu support.
cs: Pokud potřebujete podporu GMenu, použijte <link xref="GtkApplicationWindow.vala">Aplikační okno</link>.

note: (itstool) path: page/code
en: /* This is the application. */
    public class Application : Gtk.Application {
    
    	/* Constructor */
    	public Application () {
    		Object (application_id: "org.example.window");
    	}
    
    	/* Override the 'activate' signal of GLib.Application,
    	 * which is inherited by Gtk.Application. */
    	public override void activate () {
    
    		var window = new Gtk.Window ();
    		window.title = "Welcome to GNOME";
    
    		/* The following 3 lines are included here to introduce
    		 * you to ways you can adjust the toplevel window to suit
    		 * your needs.  Uncomment them to see what they do.
    		 */
    
    		//window.border_width = 10;
    		//window.set_default_size (350, 70);
    		//window.window_position = Gtk.WindowPosition.CENTER;
    
    		/* Add the window to this application. */
    		this.add_window (window);
    
    		/* Show the window. */
    		window.show ();
    	}
    }
    
    /* The main function creates the application and runs it.*/
    int main (string[] args) {
    	var app = new Application ();
    	return app.run (args);
    }
cs: /* Toto je aplikace. */
    public class Application : Gtk.Application {
    
    	/* Konstruktor */
    	public Application () {
    		Object (application_id: "org.example.window");
    	}
    
    	/* Přepíše signál "activate" z GLib.Application, 
    	 * která je zděděná z Gtk.Application. */
    	public override void activate () {
    
    		var window = new Gtk.Window ();
    		window.title = "Welcome to GNOME";
    
    		/* Následující 3 řádky jsou zde uvedeny, aby vám ukázaly
    		 * způsoby, jak si můžete přizpůsobit okno nejvyšší úrovně
    		 * svým potřebám. Zrušte zakomentování a uvidíte, co dělají.
    		 */
    
    		//window.border_width = 10;
    		//window.set_default_size (350, 70);
    		//window.window_position = Gtk.WindowPosition.CENTER;
    
    		/* Přidá okno do aplikace. */
    		this.add_window (window);
    
    		/* Zobrazí okno. */
    		window.show ();
    	}
    }
    
    /* Funkce main vytvoří aplikaci a spustí ji. */
    int main (string[] args) {
    	var app = new Application ();
    	return app.run (args);
    }

note: (itstool) path: info/desc
en: Tutorial for writing a custom <code>GSource</code> implementation
cs: Výuka psaní vlastní implementace <code>GSource</code>.

note: (itstool) path: page/title
en: Custom GSources
cs: Vlastní GSource

note: (itstool) path: synopsis/title
en: Summary
cs: Souhrn

note: (itstool) path: synopsis/p
en: This article is a tutorial on creating a custom <code>GSource</code>. For the reference documentation, see the <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GSource">GLib API reference</link>.
cs: Tento článek je výukou ve vytváření vlastních <code>GSource</code>. Ohledně referenční dokumentace se podívejte do <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GSource">referenční příručky k API knihovny GLib</link>.

note: (itstool) path: section/title
en: What is <code>GSource</code>?
cs: Co je to <code>GSource</code>?

note: (itstool) path: section/p
en: A <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GSource"><code>GSource</code></link> is an expected event with an associated callback function which will be invoked when that event is received. An event could be a timeout or data being received on a socket, for example.
cs: <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GSource"><code>GSource</code></link> je očekávaná událost s přiřazenou funkcí zpětného volání, která bude vyvolána, když je událost přijata. Událostí může být například vypršení času nebo přijetí dat na soketu.

note: (itstool) path: section/p
en: GLib contains various types of <code>GSource</code>, but also allows applications to define their own, allowing custom events to be integrated into the main loop.
cs: GLib obsahuje různé typy <code>GSource</code>, ale umožňuje také aplikacím definovat si své vlastní, díky čemuž můžete začlenit vlastní události do hlavní smyčky.

note: (itstool) path: section/p
en: The structure of a <code>GSource</code> and its virtual functions are documented in detail in the <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GSourceFuncs">GLib API reference</link>.
cs: Struktura <code>GSource</code> a jeho virtuální funkce jsou podrobně zdokumentovány v <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GSourceFuncs">referenční příručce k API GLib</link>.

note: (itstool) path: section/title
en: A Message Queue Source
cs: Zdroj „fronta zpráv“

note: (itstool) path: section/p
en: As a running example, a message queue source will be used which dispatches its callback whenever a message is enqueued to a queue internal to the source (potentially from another thread).
cs: Jak funkční příklad je použit zdroj fronty zpráv, který posílá svá zpětná volání, kdykoliv je do interní fronty ve zdroji zařazena zpráva (teoreticky z jiného vlákna).

note: (itstool) path: section/p
en: This type of source is useful for efficiently transferring large numbers of messages between main contexts. The alternative is transferring each message as a separate idle <code>GSource</code> using <code>g_source_attach()</code>. For large numbers of messages, this means a lot of allocations and frees of <code>GSource</code>s.
cs: Tento typ zdroje je vhodný pro efektivní přenosy velkého množství zpráv mezi hlavními kontexty. Alternativou je přenášet každou zprávu jako samostatný <code>GSource</code> pomocí <code>g_source_attach()</code>. Pro opravdu velké množství zpráv to znamená velký počet přidělování a uvolňování zdrojů <code>GSource</code>.

note: (itstool) path: section/title
en: Structure
cs: Struktura

note: (itstool) path: section/p
en: Firstly, a structure for the source needs to be declared. This must contain a <code>GSource</code> as its parent, followed by the private fields for the source: the queue and a function to call to free each message once finished with.
cs: Nejprve potřebujeme deklarovat strukturu pro zdroj. Ta musí obsahovat <code>GSource</code> jako svého rodiče, následovaného soukromými poli pro zdroj: frontou <code>queue</code> a funkcí <code>destroy_message</code>, která se volá, aby po dokončení práce se zprávou, zprávu uvolnila z paměti.

note: (itstool) path: section/code
en: 
    typedef struct {
      GSource         parent;
      GAsyncQueue    *queue;  /* owned */
      GDestroyNotify  destroy_message;
    } MessageQueueSource;
cs: 
    typedef struct {
      GSource         parent;
      GAsyncQueue    *queue;  /* vlastněno */
      GDestroyNotify  destroy_message;
    } MessageQueueSource;

note: (itstool) path: section/title
en: Prepare Function
cs: Funkce prepare()

note: (itstool) path: section/p
en: Next, the prepare function for the source must be defined. This determines whether the source is ready to be dispatched. As this source is using an in-memory queue, this can be determined by checking the queue’s length: if there are elements in the queue, the source can be dispatched to handle them.
cs: Následně připravíme funkci, které musí být pro zdroj definována. Určuje, jestli je zdroj připraven posílat. Protože tento zdroj používá frontu v paměti, můžeme to určit pomocí kontroly délky fronty. Jestliže jsou ve frontě nějaké prvky, zdroj je může posílat, aby je obsloužil.

note: (itstool) path: section/title
en: Check Function
cs: Funkce check()

note: (itstool) path: section/p
en: As this source has no file descriptors, the prepare and check functions essentially have the same job, so a check function is not needed. Setting the field to <code>NULL</code> in <code>GSourceFuncs</code> bypasses the check function for this source type.
cs: Protože tento zdroj nemá žádné popisovače souborů, funkce prepare a check dělají v podstatě tu samou práci, takže funkce check není zapotřebí. Nastavením pole na <code>NULL</code> v <code>GSourceFuncs</code> funkce check pro tento typ zdroje obejdeme.

note: (itstool) path: section/title
en: Dispatch Function
cs: Funkce dispatch()

note: (itstool) path: section/p
en: For this source, the dispatch function is where the complexity lies. It needs to dequeue a message from the queue, then pass that message to the <code>GSource</code>’s callback function. No messages may be queued: even through the prepare function returned true, another source wrapping the same queue may have been dispatched in the mean time and taken the final message from the queue. Further, if no callback has been set for the <code>GSource</code> (which is allowed), the message must be destroyed and silently dropped.
cs: U tohoto zdroje je funkce <code>dispatch</code> místo, kde se nachází to nejsložitější. Musí vyřadit zprávu z fronty, pak tuto zprávu předat do funkce zpětného volání z <code>GSource</code>. Ve frontě nemusí být žádná zpráva: i přesto, že funkce <code>prepare</code> vrátila <code>true</code>, jiný zdroj postavený nad touto frontou mohl být mezitím obeslán a zprávu nakonec z fronty odebrat. Navíc, jestliže nebylo nastaveno žádné zpětné volání pro <code>GSource</code> (což je dovolené), musí být zpráva zlikvidována a tiše zahozena.

note: (itstool) path: section/p
en: If both a message and callback are set, the callback can be invoked on the message and its return value propagated as the return value of the dispatch function. This is <code>FALSE</code> to destroy the <code>GSource</code> and <code>TRUE</code> to keep it alive, just as for <code>GSourceFunc</code> — these semantics are the same for all dispatch function implementations.
cs: Když je nastavena zpráva a zpětné volání, může být zpětné volání vyvoláno zprávou a jeho návratová hodnota je propagována jako návratová hodnota funkce <code>dispatch</code>. Je to <code>FALSE</code> pro zlikvidování <code>GSource</code> a <code>TRUE</code> pro jeho zachování, stejně jako u <code>GSourceFunc</code> — tyto sémantiky jsou stejné u všech implementací funkce <code>dispatch</code>.

note: (itstool) path: section/code
en: 
    /* Pop a message off the queue. */
    message = g_async_queue_try_pop (message_queue_source-&gt;queue);
    
    /* If there was no message, bail. */
    if (message == NULL)
      {
        /* Keep the source around to handle the next message. */
        return TRUE;
      }
    
    /* @func may be %NULL if no callback was specified.
     * If so, drop the message. */
    if (func == NULL)
      {
        if (message_queue_source-&gt;destroy_message != NULL)
          {
            message_queue_source-&gt;destroy_message (message);
          }
    
        /* Keep the source around to consume the next message. */
        return TRUE;
      }
    
    return func (message, user_data);
cs: 
    /* Vytáhne zprávu z fronty */
    message = g_async_queue_try_pop (message_queue_source-&gt;queue);
    
    /* Když žádná zpráva není, opustíme to */
    if (message == NULL)
      {
        /* Udrží zdroj pro zpracování následující zprávy */
        return TRUE;
      }
    
    /* @func může být %NULL, pokud nění určeno žádné zpětné volání
     * Jestli tomu tak je, zahodí zprávu */
    if (func == NULL)
      {
        if (message_queue_source-&gt;destroy_message != NULL)
          {
            message_queue_source-&gt;destroy_message (message);
          }
    
        /* Udrží zdroj pro spotřebování následující zprávy */
        return TRUE;
      }
    
    return func (message, user_data);

note: (itstool) path: section/title
en: Callback Functions
cs: Funkce zpětného volání

note: (itstool) path: section/p
en: The callback from a <code>GSource</code> does not have to have type <code>GSourceFunc</code>. It can be whatever function type is called in the source’s dispatch function, as long as that type is sufficiently documented.
cs: Zpětné volání z <code>GSource</code> nemusí mít typ <code>GSourceFunc</code>. Může to být jakýkoliv typ funkce, který je volán ve funkci <code>dispatch</code>, pokud je daný typ dostatečně zdokumentován.

note: (itstool) path: section/p
en: Normally, <code>g_source_set_callback()</code> is used to set the callback function for a source instance. With its <code>GDestroyNotify</code>, a strong reference can be held to keep an object alive while the source is still alive:
cs: Normálně se k nastavení funkce zpětného volání pro instanci zdroje používá <code>g_source_set_callback()</code>. Spolu s <code>GDestroyNotify</code> může být udržován silný odkaz kvůli zachování objektu při životě, dokud je existuje zdroj:

note: (itstool) path: section/p
en: However, <code>GSource</code> has a layer of indirection for retrieving this callback, exposed as <code>g_source_set_callback_indirect()</code>. This allows GObject to set a <code>GClosure</code> as the callback for a source, which allows for sources which are automatically destroyed when an object is finalized — a <em>weak</em> reference, in contrast to the <em>strong</em> reference above:
cs: Nicméně, <code>GSource</code> má nepřímou vrstvu pro získání tohoto zpětného volání, vystavenou jako <code>g_source_set_callback_indirect()</code>. Ta umožňuje u <code>GObject</code> nastavit <code>GClosure</code> jako zpětné volání pro zdroj, která umožňuje zdroje, které jsou automaticky likvidovány, když je objekt finalizován – <em>slabý</em> odkaz, v kontrastu k <em>silnému</em> odkazu výše:

note: (itstool) path: section/p
en: It also allows for a generic, closure-based ‘dummy’ callback, which can be used when a source needs to exist but no action needs to be performed in its callback:
cs: Obecně je možné i uzavřené „fiktivní“ zpětné volání, které může být použito, když je potřeba, aby zdroj existoval, ale není potřeba provést žádnou činnost při jeho zpětném volání:

note: (itstool) path: section/title
en: Constructor
cs: Konstruktor

note: (itstool) path: section/p
en: Finally, the <code>GSourceFuncs</code> definition of the <code>GSource</code> can be written, alongside a construction function. It is typical practice to expose new source types simply as <code>GSource</code>s, not as the subtype structure; so the constructor returns a <code>GSource*</code>.
cs: Konečně může být napsána definice <code>GSourceFuncs</code> pro <code>GSource</code>, spolu s funkcí konstruktoru. V praxi je typické vystavit nové typy zdrojů jednoduše jako <code>GSource</code>, ne jako podtyp struktury, takže konstruktor vrací <code>GSource*</code>.

note: (itstool) path: section/p
en: The example constructor here also demonstrates use of a child source to support cancellation conveniently. If the <code>GCancellable</code> is cancelled, the application’s callback will be dispatched and can check for cancellation. (The application code will need to make a pointer to the <code>GCancellable</code> available to its callback, as a field of the callback’s user data set in <code>g_source_set_callback()</code>).
cs: Konstruktor v tomto příkladu rovněž předvádí použití podřízeného zdroje pro podporu pohodlného zrušení. Když je <code>GCancellable</code> zrušen, bude obesláno zpětné volání aplikace a může ověřit zrušení. (Kód aplikace bude muset vytvořit ukazatel na <code>GCancellable</code> dostupný jeho zpětnému volání, v podobě parametru s uživatelskými daty zpětného volání v <code>g_source_set_callback()</code>.)

note: (itstool) path: section/code
en: 
    GSource *
    message_queue_source_new (GAsyncQueue    *queue,
                              GDestroyNotify  destroy_message,
                              GCancellable   *cancellable)
    {
      GSource *source;  /* alias of @message_queue_source */
      MessageQueueSource *message_queue_source;  /* alias of @source */
    
      g_return_val_if_fail (queue != NULL, NULL);
      g_return_val_if_fail (cancellable == NULL ||
                            G_IS_CANCELLABLE (cancellable), NULL);
    
      source = g_source_new (&amp;message_queue_source_funcs,
                             sizeof (MessageQueueSource));
      message_queue_source = (MessageQueueSource *) source;
    
      /* The caller can overwrite this name with something more useful later. */
      g_source_set_name (source, "MessageQueueSource");
    
      message_queue_source-&gt;queue = g_async_queue_ref (queue);
      message_queue_source-&gt;destroy_message = destroy_message;
    
      /* Add a cancellable source. */
      if (cancellable != NULL)
        {
          GSource *cancellable_source;
    
          cancellable_source = g_cancellable_source_new (cancellable);
          g_source_set_dummy_callback (cancellable_source);
          g_source_add_child_source (source, cancellable_source);
          g_source_unref (cancellable_source);
        }
    
      return source;
    }
cs: 
    GSource *
    message_queue_source_new (GAsyncQueue    *queue,
                              GDestroyNotify  destroy_message,
                              GCancellable   *cancellable)
    {
      GSource *source;  /* přezdívka pro @message_queue_source */
      MessageQueueSource *message_queue_source;  /* přezdívka pro @source */
    
      g_return_val_if_fail (queue != NULL, NULL);
      g_return_val_if_fail (cancellable == NULL ||
                            G_IS_CANCELLABLE (cancellable), NULL);
    
      source = g_source_new (&amp;message_queue_source_funcs,
                             sizeof (MessageQueueSource));
      message_queue_source = (MessageQueueSource *) source;
    
      /* Volající může později přepsat tento název něčím vhodnějším. */
      g_source_set_name (source, "MessageQueueSource");
    
      message_queue_source-&gt;queue = g_async_queue_ref (queue);
      message_queue_source-&gt;destroy_message = destroy_message;
    
      /* Přidá zdroj, který lze zrušit. */
      if (cancellable != NULL)
        {
          GSource *cancellable_source;
    
          cancellable_source = g_cancellable_source_new (cancellable);
          g_source_set_dummy_callback (cancellable_source);
          g_source_add_child_source (source, cancellable_source);
          g_source_unref (cancellable_source);
        }
    
      return source;
    }

note: (itstool) path: section/title
en: Complete Example
cs: Celý příklad

note: (itstool) path: listing/title
en: Complete Example Code
cs: Úplný kód příkladu

note: (itstool) path: listing/code
en: /**
     * MessageQueueSource:
     *
     * This is a #GSource which wraps a #GAsyncQueue and is dispatched whenever a
     * message can be pulled off the queue. Messages can be enqueued from any
     * thread.
     *
     * The callbacks dispatched by a #MessageQueueSource have type
     * #MessageQueueSourceFunc.
     *
     * #MessageQueueSource supports adding a #GCancellable child source which will
     * additionally dispatch if a provided #GCancellable is cancelled.
     */
    typedef struct {
      GSource         parent;
      GAsyncQueue    *queue;  /* owned */
      GDestroyNotify  destroy_message;
    } MessageQueueSource;
    
    /**
     * MessageQueueSourceFunc:
     * @message: (transfer full) (nullable): message pulled off the queue
     * @user_data: user data provided to g_source_set_callback()
     *
     * Callback function type for #MessageQueueSource.
     */
    typedef gboolean (*MessageQueueSourceFunc) (gpointer message,
                                                gpointer user_data);
    
    static gboolean
    message_queue_source_prepare (GSource *source,
                                  gint    *timeout_)
    {
      MessageQueueSource *message_queue_source = (MessageQueueSource *) source;
    
      return (g_async_queue_length (message_queue_source-&gt;queue) &gt; 0);
    }
    
    static gboolean
    message_queue_source_dispatch (GSource     *source,
                                   GSourceFunc  callback,
                                   gpointer     user_data)
    {
      MessageQueueSource *message_queue_source = (MessageQueueSource *) source;
      gpointer message;
      MessageQueueSourceFunc func = (MessageQueueSourceFunc) callback;
    
      /* Pop a message off the queue. */
      message = g_async_queue_try_pop (message_queue_source-&gt;queue);
    
      /* If there was no message, bail. */
      if (message == NULL)
        {
          /* Keep the source around to handle the next message. */
          return TRUE;
        }
    
      /* @func may be %NULL if no callback was specified.
       * If so, drop the message. */
      if (func == NULL)
        {
          if (message_queue_source-&gt;destroy_message != NULL)
            {
              message_queue_source-&gt;destroy_message (message);
            }
    
          /* Keep the source around to consume the next message. */
          return TRUE;
        }
    
      return func (message, user_data);
    }
    
    static void
    message_queue_source_finalize (GSource *source)
    {
      MessageQueueSource *message_queue_source = (MessageQueueSource *) source;
    
      g_async_queue_unref (message_queue_source-&gt;queue);
    }
    
    static gboolean
    message_queue_source_closure_callback (gpointer message,
                                           gpointer user_data)
    {
      GClosure *closure = user_data;
      GValue param_value = G_VALUE_INIT;
      GValue result_value = G_VALUE_INIT;
      gboolean retval;
    
      /* The invoked function is responsible for freeing @message. */
      g_value_init (&amp;result_value, G_TYPE_BOOLEAN);
      g_value_init (&amp;param_value, G_TYPE_POINTER);
      g_value_set_pointer (&amp;param_value, message);
    
      g_closure_invoke (closure, &amp;result_value, 1, &amp;param_value, NULL);
      retval = g_value_get_boolean (&amp;result_value);
    
      g_value_unset (&amp;param_value);
      g_value_unset (&amp;result_value);
    
      return retval;
    }
    
    static GSourceFuncs message_queue_source_funcs =
      {
        message_queue_source_prepare,
        NULL,  /* check */
        message_queue_source_dispatch,
        message_queue_source_finalize,
        (GSourceFunc) message_queue_source_closure_callback,
        NULL,
      };
    
    /**
     * message_queue_source_new:
     * @queue: the queue to check
     * @destroy_message: (nullable): function to free a message, or %NULL
     * @cancellable: (nullable): a #GCancellable, or %NULL
     *
     * Create a new #MessageQueueSource, a type of #GSource which dispatches for
     * each message queued to it.
     *
     * If a callback function of type #MessageQueueSourceFunc is connected to the
     * returned #GSource using g_source_set_callback(), it will be invoked for each
     * message, with the message passed as its first argument. It is responsible for
     * freeing the message. If no callback is set, messages are automatically freed
     * as they are queued.
     *
     * Returns: (transfer full): a new #MessageQueueSource
     */
    GSource *
    message_queue_source_new (GAsyncQueue    *queue,
                              GDestroyNotify  destroy_message,
                              GCancellable   *cancellable)
    {
      GSource *source;  /* alias of @message_queue_source */
      MessageQueueSource *message_queue_source;  /* alias of @source */
    
      g_return_val_if_fail (queue != NULL, NULL);
      g_return_val_if_fail (cancellable == NULL ||
                            G_IS_CANCELLABLE (cancellable), NULL);
    
      source = g_source_new (&amp;message_queue_source_funcs,
                             sizeof (MessageQueueSource));
      message_queue_source = (MessageQueueSource *) source;
    
      /* The caller can overwrite this name with something more useful later. */
      g_source_set_name (source, "MessageQueueSource");
    
      message_queue_source-&gt;queue = g_async_queue_ref (queue);
      message_queue_source-&gt;destroy_message = destroy_message;
    
      /* Add a cancellable source. */
      if (cancellable != NULL)
        {
          GSource *cancellable_source;
    
          cancellable_source = g_cancellable_source_new (cancellable);
          g_source_set_dummy_callback (cancellable_source);
          g_source_add_child_source (source, cancellable_source);
          g_source_unref (cancellable_source);
        }
    
      return source;
    }
cs: /**
     * MessageQueueSource:
     *
     * Jde o #GSource obalující #GAsyncQueue a je poslán kdykoliv je do fronty
     * vložena zpráva. Zprávy mohou být vkládány z libovolného vlákna.
     *
     * Zpětná volání poslaná od #MessageQueueSource mají typ
     * #MessageQueueSourceFunc.
     *
     * #MessageQueueSource podporuje přídávání synovských zdrojů #GCancellable,
     * které budou poslány navíc, když je poskytující #GCancellable rušen.
     */
    typedef struct {
      GSource         parent;
      GAsyncQueue    *queue;  /* vlastník */
      GDestroyNotify  destroy_message;
    } MessageQueueSource;
    
    /**
     * MessageQueueSourceFunc:
     * @message: (úplný přenos) (může být null): zprávy vytažená z fronty
     * @user_data: uživatelská data poskytnutá do g_source_set_callback()
     *
     * Typ funkce zpětného volání pro #MessageQueueSource
     */
    typedef gboolean (*MessageQueueSourceFunc) (gpointer message,
                                                gpointer user_data);
    
    static gboolean
    message_queue_source_prepare (GSource *source,
                                  gint    *timeout_)
    {
      MessageQueueSource *message_queue_source = (MessageQueueSource *) source;
    
      return (g_async_queue_length (message_queue_source-&gt;queue) &gt; 0);
    }
    
    static gboolean
    message_queue_source_dispatch (GSource     *source,
                                   GSourceFunc  callback,
                                   gpointer     user_data)
    {
      MessageQueueSource *message_queue_source = (MessageQueueSource *) source;
      gpointer message;
      MessageQueueSourceFunc func = (MessageQueueSourceFunc) callback;
    
      /* Vytáhne zprávu z fronty */
      message = g_async_queue_try_pop (message_queue_source-&gt;queue);
    
      /* Když zde není žádná zpráva, skončit */
      if (message == NULL)
        {
          /* Zachová zdroj pro obsluhu následující zprávy */
          return TRUE;
        }
    
      /* @func může být %NULL, když nebylo určeno žádné zpětné volání
       * Pokud tomu tak je, zahodí zprávu */
      if (func == NULL)
        {
          if (message_queue_source-&gt;destroy_message != NULL)
            {
              message_queue_source-&gt;destroy_message (message);
            }
    
          /* Zachová zdroj pro zpracování následující zprávy */
          return TRUE;
        }
    
      return func (message, user_data);
    }
    
    static void
    message_queue_source_finalize (GSource *source)
    {
      MessageQueueSource *message_queue_source = (MessageQueueSource *) source;
    
      g_async_queue_unref (message_queue_source-&gt;queue);
    }
    
    static gboolean
    message_queue_source_closure_callback (gpointer message,
                                           gpointer user_data)
    {
      GClosure *closure = user_data;
      GValue param_value = G_VALUE_INIT;
      GValue result_value = G_VALUE_INIT;
      gboolean retval;
    
      /* Vyvolaná funkce je zodpovědná za uvolnění @message */
      g_value_init (&amp;result_value, G_TYPE_BOOLEAN);
      g_value_init (&amp;param_value, G_TYPE_POINTER);
      g_value_set_pointer (&amp;param_value, message);
    
      g_closure_invoke (closure, &amp;result_value, 1, &amp;param_value, NULL);
      retval = g_value_get_boolean (&amp;result_value);
    
      g_value_unset (&amp;param_value);
      g_value_unset (&amp;result_value);
    
      return retval;
    }
    
    static GSourceFuncs message_queue_source_funcs =
      {
        message_queue_source_prepare,
        NULL,  /* check */
        message_queue_source_dispatch,
        message_queue_source_finalize,
        (GSourceFunc) message_queue_source_closure_callback,
        NULL,
      };
    
    /**
     * message_queue_source_new:
     * @queue: fronta ke zkontrolování
     * @destroy_message: (může být null): funkce pro uvolnění zprávy nebo %NULL
     * @cancellable: (může být null): #GCancellable nebo %NULL
     *
     * Vytvoří nový #MessageQueueSource typu #GSource, který posílá při každé
     * zprávě přidané do fronty
     *
     * Pokud je funkce zpětného volání typu #MessageQueueSourceFunc napojená na
     * vrácený #GSource pomocí g_source_set_callback(), bude vyvolána pro každou
     * zpráv, přičemž zpráva bude předána jako první argument. Zodpovídá za 
     * uvolnění zprávy. Pokud žádné zpětné volání není nastaveno, je zpráva
     * automaticky uvolněna, stejně jako byla přidána.
     *
     * Vrací: (úplný přenos): nový #MessageQueueSource
     */
    GSource *
    message_queue_source_new (GAsyncQueue    *queue,
                              GDestroyNotify  destroy_message,
                              GCancellable   *cancellable)
    {
      GSource *source;  /* přezdívka pro @message_queue_source */
      MessageQueueSource *message_queue_source;  /* přezdívka @source */
    
      g_return_val_if_fail (queue != NULL, NULL);
      g_return_val_if_fail (cancellable == NULL ||
                            G_IS_CANCELLABLE (cancellable), NULL);
    
      source = g_source_new (&amp;message_queue_source_funcs,
                             sizeof (MessageQueueSource));
      message_queue_source = (MessageQueueSource *) source;
    
      /* Volající může přepsat tento název něčím vhodnější pro pozdější použití */
      g_source_set_name (source, "MessageQueueSource");
    
      message_queue_source-&gt;queue = g_async_queue_ref (queue);
      message_queue_source-&gt;destroy_message = destroy_message;
    
      /* Přidá zrušitelný zdroj */
      if (cancellable != NULL)
        {
          GSource *cancellable_source;
    
          cancellable_source = g_cancellable_source_new (cancellable);
          g_source_set_dummy_callback (cancellable_source);
          g_source_add_child_source (source, cancellable_source);
          g_source_unref (cancellable_source);
        }
    
      return source;
    }

note: (itstool) path: section/title
en: Further Examples
cs: Další příklady

note: (itstool) path: section/p
en: Sources can be more complex than the example given above. In <link href="http://nice.freedesktop.org/">libnice</link>, a custom <code>GSource</code> is needed to poll a set of sockets which changes dynamically. The implementation is given as <code>ComponentSource</code> in <link href="http://cgit.freedesktop.org/libnice/libnice/tree/agent/component.c#n941">component.c</link> and demonstrates a more complex use of the prepare function.
cs: Zdroje mohou být mnohem složitější, než ve výše uvedeném příkladu. V knihovně <link href="http://nice.freedesktop.org/">libnice</link> je vlastní <code>GSource</code> zapotřebí k dotazování sady soketů, která se dynamicky mění. Implementace je dána jako <code>ComponentSource</code> v <link href="http://cgit.freedesktop.org/libnice/libnice/tree/agent/component.c#n941">component.c</link> a předvádí podstatně složitější použití funkce <code>prepare</code>.

note: (itstool) path: section/p
en: Another example is a custom source to interface GnuTLS with GLib in its <code>GTlsConnection</code> implementation. <link href="https://gitlab.gnome.org/GNOME/glib-networking/blob/master/tls/gnutls/gtlsconnection-gnutls.c#L1154"><code>GTlsConnectionGnutlsSource</code></link> synchronizes the main thread and a TLS worker thread which performs the blocking TLS operations.
cs: Jiným příkladem je vlastní zdroj k rozhraní GnuTLS s GLib v jeho implementaci <code>GTlsConnection</code>. <link href="https://gitlab.gnome.org/GNOME/glib-networking/blob/master/tls/gnutls/gtlsconnection-gnutls.c#L1154"><code>GTlsConnectionGnutlsSource</code></link> synchronizuje hlavní vlákno s pracovním vláknem TLS, které provádí blokování operací TLS.
