# Vývojářská příručka ke zpřístupnění GNOME

## Co je to zpřístupnění

Zpřístupnění znamená pomoc lidem s postižením, aby se mohli účastnit běžných každodenních činností. Což zahrnuje práci a využívání služeb, věcí a informací. Součástí GNOME jsou knihovny a podpůrný základní rámec umožňující lidem s postižením používat veškerou funkcionalitu uživatelského pracovního prostředí GNOME.

Ve spojení s asistenčními technologiemi – hlasovým rozhraním, čtečkou obrazovky, alternativním vstupním zařízením, apod. – v případě potřeby mohou lidé s trvalým nebo dočasným postižením i navzdory svému postižení používat pracovní prostředí GNOME a aplikace. Asistenční technologie se mohou hodit i ostatním lidem, když jsou mimo domov nebo kancelář. Například v dopravní zácpě můžete využít hlasový vstup a výstup ke kontrole své elektronické pošty.

Asistenční technologie získávají informace od aplikací pře API ATK (Accessibility Toolkit), který můžete najít v modulu atk v repozitářích GNOME. Díky tomu, že je podpora pro API zpřístupnění vestavěná ve widgetech GNOME, měly by vaše programy pro GNOME fungovat s asistenčními technologiemi poměrně dobře i bez nějakého přispění z vaší strany. Například umí asistenční technologie automaticky číst popisky widgetů, které ve svém programu nastavujete tak jako tak (např. pomocí zavolání funkce jako je `gtk_label_set_text()` nebo `gtk_button_new_with_label()`). Umí také zjistit, jestli je k widgetu přiřazena nějaká vysvětlivka a použít ji k popisu widgetu uživateli.

Když věnujete trochu úsilí navíc, může váš program fungovat s asistenčními technologiemi ještě lépe. Mimo toho, že tím pomůžete jednotlivým uživatelům, zatraktivníte tím svůj výtvor také pro vládní a školské zakázky, nehledě na to, že zpřístupnění v těchto případech mnohdy požaduje zákon.

### Typy postižení

Jen v samotné české republice je odhadem přes milión lidí s postižením, kterým může být používání počítače ztíženo kvůli nepřístupnému návrhu softwaru. Globálně má okolo 8 % lidí, který používají webové stránky, nějaký druh postižení. Jednotlivá postižení spadají do některé z těchto kategorií:

- Zraková postižení – může se pohybovat od zhoršeného vidění (včetně, mimo jiné, šerosleposti, silné krátkozrakosti nebo dalekozrakosti, barvosleposti a tunelového vidění) po úplnou slepotu. Špatná volba velikosti textu a barev a úlohy vyžadující přesnou koordinaci ruky a oka (jako pohyb myší) mohou těmto lidem způsobovat problémy.

- Pohybové postižení – pro uživatele se špatným ovládáním svalstva nebo svalovou distrofií může být obtížné používat standardní klávesnici nebo myš. Například nemohou zmáčknout dvě klávesy současně nebo mohou s větší pravděpodobností zmáčknout klávesu nechtěně.

- Sluchová postižení – může se pohybovat od schopnosti slyšet nějaké zvuky, ale nedokázat rozpoznat slova, po úplnou hluchotu. Aplikace, které podávají podstatné informace jen ve zvukové podobě, mohou těmto uživatelům působit problémy.

- Poruchy rozpoznávání a jazykové – mohou se pohybovat od dyslexie po obtíže s pamatováním věcí, řešením problémů nebo chápáním a používání mluveného či psaného jazyka. Komplikované nebo nekonzistentní zobrazení či špatná volba slov mohou těmto uživatelům ztížit používání počítače.

- Poruchy vnímání – určité druhy světel nebo zvuků mohou způsobit u vnímavějších uživatelů epileptický záchvat.

### Jak zpřístupnění funguje v GNOME

ATK (Accessibility Toolkit – sada nástrojů zpřístupnění) popisuje sadu rozhraní, která musí být implementována v komponentách GUI, aby byly přístupné. Rozhraní jsou nezávislá na vývojářských sadách – implementaci je možné napsat pro libovolnou množinu widgetů, jako je GTK, Motif nebo Qt.

Implementace pro widgety GTK je v modulu nazývaném GAIL (GNOME Accessibility Implementation Library), který je dynamicky načítán za běhu aplikacemi GTK. Když je načten, tak části vaší aplikace, které používají standardní widgety GTK, budou mít základní úroveň zpřístupnění, aniž by bylo v aplikaci potřeba cokoliv upravovat. Když knihovna GAIL není načtená, budou mít widgety GTK výchozí implementaci zpřístupnění, která v podstatě nevrací žádné informace, i když formálně vyhovují API ATK. Aplikace, které používají ovládací prvky Bonobo, zejména ty nezpracovávané, rovněž načtou kód pro podporu zpřístupnění z modulu libgail-gnome. To, jestli aplikace v pracovní prostředí GNOME automaticky načte nebo nenačte knihovny s podporou zpřístupnění, závisí na hodnotě klíče gconf „/desktop/gnome/interface/accessibility“. Pravdivostní hodnota „true“ zapne podporu pro asistenční technologie a aplikace, které volají gnome_program_init automaticky za běhu načtou příslušné knihovny zpřístupnění. Aplikace čistě s GTK+, například ty, které používají gtk+, ale nejsou slinkovány s libgnome, musí spoléhat na hodnotu proměnné prostředí GTK_MODULES, která musí být nastavená na „gail:atk-bridge“, aby se zapnula podpora asistenčních technologií.

Většina asistenčních technologií, které běží v jiných pracovních prostředích, zjistila, že je z historických důvodů potřeba se starat o složitý mimoobrazovkový model běžící aplikace založený na zachytávání událostí OS, o používání nepodporovaných OS a aplikačních funkcí a API a o silně nepřenositelné techniky. To udělalo z podpory asistenčních technologií něco snadno rozbitelného a značně závislého na OS a aplikaci, nebo dokonce verzi aplikace. Oproti tomu v pracovním prostředí GNOME jsou všechny informace požadované AT poskytovány běžící aplikací přes základní rámec přístupnosti do SPI (Service Provider Interface) nezávislého na použité nástrojové sadě. SPI poskytuje prostředky pro unixové asistenční technologie, jako je čtečka obrazovky a lupa obrazovky, aby získaly informace o zpřístupnění od běžících aplikací přes jednotné a stabilní API, a ve většině případů dokáže vyloučit potřebu mimoobrazovkového modelu. Podpora zpřístupnění pro aplikace je „zabudovaná“ v nástrojové sadě pro vývoj aplikací pomocí příslušného API (např. ATK pro většinu nativních aplikací v jazyce C a Java Accessibility API pro aplikace v jazyce Java) a exportována do běžného rozhraní „AT-SPI“ přes příslušný „most“ (viz schéma níže).

#### Architektura zpřístupnění v GNOME

Schéma architektury zpřístupnění v GNOME

Vestavěná podpora zpřístupnění v GNOME znamená, že aplikace vytvořené pomocí standardních widgetů GNOME dostávají podporu pro asistenční technologie „zdarma“ za předpokladu, že widgety nejsou používány neobvyklým způsobem, které by byl v konfliktu s touto vestavěnou podporou.

Widget gtk+/GNOME je zpřístupněný, pokud dodržuje obecná pravidla zpřístupnění uvedená v tomto dokumentu a implementuje rozhraní ATK odpovídající jeho roli v uživatelském rozhraní. Implementace ATK jsou poskytovány pro standardní widgety nástrojové sady GNOME (např. nezastaralé widgety gtk+ a GNOME) a nové widgety, které jsou jednoduše odvozeny ze stávajících widgetů GTK+ nebo GNOME, patřičnou podporu zpřístupnění většinou zdědí.

Ačkoliv vestavěná podpora zpřístupnění v GNOME poskytuje podstatnou funkcionalitu bez nutnosti úpravy částí kódu speciálně pro zpřístupnění, aplikace často vylepšují výchozí popisy pro některé widgety a přizpůsobují je na míru konkrétnímu účelu aplikace pomocí přímého volání metod ATK v aplikaci. Například, ve většině případů by aplikace měly přidat nebo změnit textové popisy u widgetů pomocí příslušného volání funkce ATK, aby asistenční technologie mohly popsat jejich účel nebo stav uživateli. Více informací viz Příručka ke kódování s podporou zpřístupnění.

Pokud vaše aplikace používá vlastní widgety, můžete mít nějakou práci s předáváním vlastností těchto widgetů asistenčním technologiím. Více informací viz Zpřístupnění vlastních komponent a Příklady, které používají API zpřístupnění.

Další informace ohledně GTK/GTK+ jdoucí více do hloubky najdete v referenční příručce GTK+, v příručce k ATK v části o GTK, ve výuce GTK+ 2.0 na webu GNOME a v oficiálních častých dotazech a odpovědích GTK+.

### Rychlý úvod pro vývojáře

Zde je pár věcí pro začátek:

#### Jak si mohu ověřit, jestli je má aplikace přístupní či nikoliv?

Abyste správně začali, podívejte se nejdříve na Jak udělat aplikace v GNOME přístupné – přehled. Než začnete psát kód, získejte přehled v Pokyny k uživatelskému rozhraní ohledně podpory zpřístupnění nebo v Příručce k programování s podporou zpřístupnění. Kontrolní seznam pro testování, až skončíte s psaním kódu, najdete v Kontrolní seznam pro uživatelské rozhraní.

#### Jaké jsou nejběžněnší nástrahy?

Kontrolní seznam pro uživatelské rozhraní pokrývá všechny oblasti, které jsou občas přehlédnuty ve stádiu návrhu.

#### Jak můžu udělat běžné věci v ATK?

Stručný seznam běžných volání ATK najdete zde.

#### Jak můžu udělat složitější věci v ATK?

Další informace viz Zpřístupnění vlastních komponent a Příklady, které používají API zpřístupnění.

#### Úvod do ATK, AT-SPI, GAIL a GTK+

Architektura zpřístupnění v GNOME

ATK je sada nástrojů, které používá GNOME k zajištění přístupnosti pro uživatele, kteří potřebují speciální podporu, aby mohli používat svůj počítač. ATK je používáno nástroji, jako je čtečka obrazovky, lupa obrazovky a vstupní zařízení, zajišťujícími plnohodnotnou práci v pracovním prostředí alternativními způsoby. Další informace viz projekt ATK na SourceForge a knihovna ATK.

AT-SPI je hlavní rozhraní služby, přes kterou se asistenční technologie dotazují a přijímají upozornění od běžících aplikací. Kompletní API si můžete projít zde. Doplňující materiály jsou dostupné od komunity KDE vyvíjející zpřístupnění.

GAIL (GNOME Accessibility Implementation Library) je implementací rozhraní zpřístupnění definovaného v ATK. GTK je nástrojová sada, která je již namapovaná na ATK pomocí modulu GAIL. Licenci, věci ke stažení a další informace můžete najít zde. Jako vynikající zdroj informací pro pokročilé využití ATK slouží i zdrojový kód GAIL. Ještě by vás mohla zajímat referenční příručka GAIL.

GTK+ je knihovna pro vytváření grafického uživatelského rozhraní. Funguje na řadě platforem unixového typu, ve Windows a na zařízeních používajících framebuffer. GTK+ je vydána pod licencí GNU Library General Public License (GNU LGPL), která umožňuje flexibilní licencování pro klientské aplikace. GTK+ má objektově orientovanou architekturu napsanou v jazyce C, která umožňuje maximální pružnost. Je napsáno napojení na další jazyky, včetně C++, Objective-C, Guille/Scheme, Perl, Python, TOM, Ada95, Free Pascal a Eiffel.

Další informace o GTK/GTK+ jdoucí více do hloubky najdete v Referenční příručce GTK+, v části o GTK v příručce ATK, ve výuce GTK+ 2.0 hostované na GNOME a v oficiálních častých dotazech a odpovědích o GTK+.

### Jak udělat aplikace v GNOME přístupné – přehled

Pokud vaše aplikace používá jen standardní widgety GTK, budete pravděpodobně muset udělat jen minimum věcí, nebo vůbec nic, aby vaše aplikace měla (rozumnou) přístupnost. Dejte ale pozor na objekty ve svém GUI, které nemají přiřazen textový popis, jako jsou grafická tlačítka nebo indikátory stavu, které nemají popisky nebo vysvětlivky.

Nejspíše také budete muset zdokonalit výchozí popis poskytovaný pro některé widgety a přizpůsobit je na míru konkrétnímu účelu widgetu ve vaší aplikaci. U těchto widgetů byste měli přidat nebo změnit textový popis pomocí příslušných funkcí ATK, aby asistenční technologie mohly popsat jejich účel nebo stav uživateli. Více informací viz Příručka k programování s podporou zpřístupnění.

Pokud vaše aplikace používá vlastní vidgety, můžete mít nějako práci s předáváním vlastností těchto widgetů asistenčním technologiím. Více informací viz Zpřístupnění vlastních komponent a Příklady, které používají API zpřístupnění. Další zajímavé věci se můžete dozvědět z prezentace, kterou měl Marc Mulcahy na konfefrenci GUADEC pod názvem „Making GNOME Applications Accessible“ (Zpřístupnění aplikací GNOME).

### Příručka k programování s podporou zpřístupnění

Zde je několik věcí, které můžete udělat ve svém kódu, abyste zajistili, že váš program bude pracovat co nejlépe s asistenčními technologiemi. (V části Pokyny k uživatelskému rozhraní ohledně podpory zpřístupnění v této příručce můžete najít seznam věcí, které byste měli vzít do úvahy, když navrhujete GUI.):

- U komponent, které nezobrazují krátký název (jako jsou grafická tlačítka), určete název pomocí `atk_object_set_name()`. Budete to chtít u čistě obrázkových tlačítek, u panelů, které poskytují logické seskupení, u textových oblastí a pod.

- Pokud nemůžete ke komponentě poskytnout vysvětlivku, použijte místo toho `atk_object_set_description()`, která poskytne popis, který mohou asistenční technologie předat uživateli. Například poskytnutí zpřístupňujícího popisu pro tlačítko Zavřít by vypadalo takto:

  #### Poskytnutí zpřístupňujícího popisu pro GtkButton

      {
        AtkObject *obj;
        obj = gtk_widget_get_accessible(button);
        atk_object_set_description(obj,_("Closes the window"));
      }

- Použijte `atk_image_set_description()` k poskytnutí textového popisu ke všem obrázkům a ikonám ve svém programu.

- Pokud několik komponent tvoří logickou skupinu, zkuste je vložit do jednoho kontejneru.

- Kdykoliv máte popisek, který popisuje jinou komponentu, použijte `atk_relation_set_add_relation()`, aby asistenční technologie dokázala najít komponentu, se kterou je popisek svázán. (Když přidružíte popisek s komponentou pomocí `gtk_label_set_mnemonic_widget()`, je vztah `ATK_RELATION_LABEL_FOR` vygenerován automaticky, takže následující kód nebude nutný):

  #### Vytvoření vztahu mezi GtkLabel a GtkWidget

      {
        GtkWidget *widget;
        GtkLabel *label;

        AtkObject *atk_widget, *atk_label;
        AtkRelationSet *relation_set;
        AtkRelation *relation;
        AtkObject *targets[1];

        atk_widget = gtk_widget_get_accessible(widget);
        atk_label = gtk_widget_get_accessible (GTK_WIDGET(label));

        relation_set = atk_object_ref_relation_set (atk_label);
        targets[0] = atk_widget;

        relation = atk_relation_new(targets,1, ATK_RELATION_LABEL_FOR);
        atk_relation_set_add(relation_set,relation);
        g_object_unref(G_OBJECT(relation));
      }

- Když vytvoříte vlastní widget, zajistěte, aby podporoval zpřístupnění. Vlastní komponenty, které jsou potomky jiných widgetů GTK, by měly přepsat zděděnou podporu zpřístupnění podle potřeby. Více informací viz zpřístupnění vlastních komponent.

- Neničte věci, které dostanete zdarma! Když bude mít vaše GUI nezpřístupněný kontejner, kterákoliv komponenta uvnitř tohoto kontejneru se může stát nepřístupnou.

### API zpřístupnění

Zde je pár základních volání API, která můžete potřebovat pro použití ve své aplikaci, když chcete zajistit, že bude pracovat s asistenčními technologiemi. Celé API zpřístupnění je rozšiřitelné, abyste mohli například psát své vlastní widgety pro podporu zpřístupnění.

### Běžně používaná volání API ATK

API | Popis
`AtkObject* gtk_widget_get_accessible (GtkWidget*)` | Vrací objekt zpřístupnění, který popisuje zadaný Widget GTK pro asistenční technologii.
`void atk_object_set_name (AtkObject*, const gchar*)` | Nastavuje název pro zpřístupněný objekt. Například, pokud je objektem grafické tlačítko, které při zmáčknutí ukončí aplikaci, může být název „Quit“.
`void atk_object_set_description (AtkObject*, const gchar*)` | Nastaví textový popis zpřístupněného objektu. Například, když je objektem grafické tlačítko „Zavřít“, může být popis „Closes the window“.
`AtkRelation* atk_relation_new (AtkObject**, gint, AtkRelationType)` | Vytvoří nový vztah mezi zadaným klíčem a zadaným seznamem cílových objektů. Vztah normálně říká asistenční technologii, že některý widget nějak souvisí s jiným. Například, že konkrétní widget GtkLabel je nadpisem widgetu GtkTreeView v tom samém okně.
`void atk_image_set_description (AtkImage*, const gchar*)` | Nastaví textový popis zpřístupněného obrázkového objektu. Například, když je objektem náhled viruální plochy v apletu na panel, může být popis „Image showing window arrangement on desktop 1“.

### Příklady, které používají API zpřístupnění

Jak bylo uvedeno již dříve, měli byste mít jen málo práce, nebo vůbec žádnou, s tím, abyste měli svoji aplikaci zpřístupněnou, když budete používat sadu widgetů GTK nebo jinou knihovnu widgetů, které implementují rozhraní ATK. Dvě hlavní obvyklé věci, kterým byste měli věnovat v takovém případě věnovat pozornost, jsou:

- Poskytnout popisy některým ovládacím prvkům a obrázkům pomocí `atk_object_set_description()` nebo `atk_image_set_description():`

  #### Nastavení popisu zpřístupnění pro tlačítko

      {
         AtkObject *obj;
         obj = gtk_widget_get_accessible(button);
         atk_object_set_description(obj,_("Opens Preferences dialog"));
      }

- Určit vztahy mezi některými neobvyklými seskupeními widgetů pomocí `atk_relation_new()` a `atk_relation_set_add()`:

  #### Definice zpřístupňujícího vztahu mezi dvěma ovládacími prvky

      {
        GtkWidget *widget;
        GtkLabel *label;

        AtkObject *atk_widget, *atk_label;
        AtkRelationSet *relation_set;
        AtkRelation *relation;
        AtkObject *targets[1];

        atk_widget = gtk_widget_get_accessible (widget);
        atk_label = gtk_widget_get_accessible (GTK_WIDGET(label));

        relation_set = atk_object_ref_relation_set (atk_label);
        targets[0] = atk_widget;

        relation = atk_relation_new(targets,1, ATK_RELATION_LABEL_FOR);
        atk_relation_set_add(relation_set,relation);
        g_object_unref(G_OBJECT(relation));
      }

Příklady ve zbytku této části se většinou věnují nuancím v celém ATK. Pokrývá techniky, které možná nebudete nikdy potřebovat jako vývojář aplikací, ale mohou vás zajímat při psaní vlastních widgetů (viz Zpřístupnění vlastních komponent) nebo když chcete napsat aplikaci pro asistenční technologii. Ať už bude účel jakýkoliv, je vynikajícím zdrojem informací pro pokročilé využití ATK přímo zdrojový kód GAIL. Upozorňujeme, že od GTK 3.1.10 byla knihovna Gail začleněna přímo do GTK+, a není již samostatným modulem.

#### Moduly Gtk

Programy, které používají GAIL (knihovnu implementující zpřístupnění pro widgety GTK), jsou napsány jako moduly GTK. Modul GTK se nahraje do programového prostoru, když proměnná prostředí `GTK_MODULES` uvádí název příslušné knihovny modulu. Pokud máte více knihoven modulů, oddělte je dvojtečkou. Například:

`setenv GTK_MODULES "libgail:libtestprops"`

Všechny moduly GTK mají funkci `gtk_module_init()`.

#### Sbírání informací o zpřístupnění z aplikace

Program, který si přeje používat volání ATK, bude pravděpodobně muset udělat jednu (nebo více) z následujících věcí:

1. Vytvořit sledování události, například pomocí funkce `atk_add_focus_tracker()`:

       atk_add_focus_tracker (_my_focus_tracker);

   kde `_my_focus_tracker()` je funkce s tímto prototypem:

       void _my_focus_tracker (AtkObject *aobject);

2. Vytvořit globální naslouchání události pomocí atk_add_global_event_listener():

       mouse_watcher_focus_id =   atk_add_global_event_listener(_my_global_listener,"Gtk:GtkWidget:enter_notify_event");

   kde `_my_global_listener` má prototyp z `_my_global_listener` v Glib. Tento příklad způsobí, že funkce `_my_global_listener()` bude volána, kdykoliv se vyskytne signál enter_notify_even na objektu `GtkWidget`.

3. K objektu ATK nejvyšší úrovně získáte přístup zavoláním následující funkce.

       AtkObject *root_obj = atk_get_root();

   Vrací `AtkObject`, který obsahuje všechna okna nejvyšší úrovně v aktuálně běžícím programu. Uživatel pak může procházet hierarchií objektů pomocí přístupu k potomkům kořenového objektu, které odpovídají oknům nejvyšší úrovně.

#### Dotazování se rozhraní objektu `AtkObject`

Když máte vyhledán `AtkObject` patřící k objektu v aplikaci (např. pomocí `gtk_widget_get_accessible()`), můžete různými způsoby zjistit, která rozhraní má implementována:

1. Použijte podporovaná makra `ATK_IS_…`, například:

   - `ATK_IS_ACTION(atkobj)`

   - `ATK_IS_COMPONENT(atkobj)`

   - atd. (pro každé rozhraní je jedno)

   Pokud makro vrací `TRUE`, volání rozhraní může být na objektu ATK bezpečně provedeno.

2. Otestujte roli `AtkObject` zavoláním `atk_object_get_role()`. Kterákoliv daná role implementuje určitý počet API pro ATK.

#### Nastavení zpracování signálu ATK

Kupříkladu použití signálu `column_inserted`:

    table_column_inserted_id = g_signal_connect_closure_by_id (my_atk_obj,
    g_signal_lookup("column_inserted", G_OBJECT_TYPE(my_atk_obj)), 0,
    g_cclosure_new(G_CALLBACK (_my_table_column_inserted_func), NULL, NULL), FALSE);

Tento kód způsobí, že funkce `_my_table_column_inserted_func()` bude volána pokaždé, když je na objektu `AtkObject` `my_atk_object` vyslán signál column_inserted.

Připojení signálu se lehce liší, když signál podporuje detaily. Signál `children_changed` podporuje detail `add`. Pro připojení k signálu, když je určen i detail `add`, se používá tato technika:

    child_added_id = g_signal_connect_closure (my_atk_obj,"children_changed::add",
    g_cclosure_new (G_CALLBACK(_my_children_changed_func), NULL, NULL), FALSE);

Tento kód způsobí, že funkce `_my_children_changed_func()` bude volána pokaždé, když je na objektu `AtkObject` `my_atk_obj` vyslán signál `children_changed` s detailem `add`.

#### Implementace objektu ATK

Budete muset implementovat vlastní objetky ATK pro widgety, které zatím nemají implementaci zpřístupnění v GAIL (nebo jiné obdobné knihovně pro jinou sadu widgetů). Měly by být implementovány jako modul GTK, který by, stejně jako před tím, měl být zahrnut v proměnné prostředí `GTK_MODULES`, aby se načetl za běhu.

##### Registr

V tomto příkladu budeme předpokládat, že máme objekt s názvem GTK_TYPE_MYTYPE. Implementace ATK bude volat `MYATKIMP_TYPE_MYTYPE`. Bude zapotřebí generátor s názvem `MYATKIMP_TYPE_MYTYPE_FACTORY`.

Abyste zaregistrovali implementaci ATK objektu GTK, musí ve funkci `gtk_module_init()` modulu následovat tyto kroky:

1. Získejte přístup k výchozímu registru:

       default_registry = atk_get_default_registry();

2. Zaregistrujte objekt ATK ve funkci `gtk_module_init()` tohoto modulu pomocí zavolání této funkce:

       atk_registry_set_factory_type (default_registry, GTK_TYPE_MYTYPE,
       MYATKIMP_TYPE_MYTYPE_FACTORY);

Tím se zaregistruje implementace AtkObject pro `GTK_TYPE_MYTYPE` do `MYATKIMP_TYPE_MYTYPE_FACTORY`. Tento generátor bude implementován, takže bude známo, jak sestavit objekty typu `MYATKIMP_TYPE_MYTYPE`.

##### Generátor

Generátor (factory) musí být implementován jako dceřiná třída typu `ATK_TYPE_OBJECT_FACTORY` a musí implementovat funkci `create_accessible()`. Tato funkce musí vytvořit příslušný `AtkObject`. Generátor lze použít k vytvoření více než jednoho typu objektu, přičemž jeho funkce `create_accessible()` musí být dostatečně chytrá, aby sestavila a vrátila správný `AtkObject`.

##### Implementace ATK pro zadaný objekt

Všechny `GObject` implementují funkci `get_type()`. Když vezmeme předchozí příklad, podle konvence pojmenování by název funkce byl `myatkimp_mytype_get_type()`.

V této funkci určujete, která rozhraní bude váš objekt implementovat. Když by se použila logika, která byla použita v této funkci `get_type()`, implementoval by objekt rozhraní `ATK_TEXT`:

###### Vzorová funkce `get_type()`

    static const GInterfaceInfo atk_text_info =
    {
       (GInterfaceInitFunc) atk_text_interface_init,
       (GInterfaceFinalizeFunc) NULL,
       NULL
    };

    g_type_add_interface_static (type, ATK_TYPE_TEXT,
                                 &atk_text_info);

Měla by být implementována funkce `atk_text_interface_init()`, která má následující prototyp:

    void atk_text_interface_init (AtkTextIface *iface);

Tato funkce by napojila volání funkce rozhraní na konkrétní implementaci následovně:

###### Napojení volání vlastního rozhraní na implementaci AtkObject

    void
    atk_text_interface_init (AtkTextIface *iface)
    {
       g_return_if_fail (iface != NULL);
       iface->get_text = myatkimp_mytype_get_text;
       iface->get_character_at_offset = myatkimp_mytype_get_character_at_offset;
       ...
    }

Potom by bylo potřeba implementovat funkce `myatkimp_mytype_get_text()`, `myatkimp_mytype_get_character_at_offset()` a zbytek funkcí rozhraní `ATK_TEXT`.

##### Implementace `AtkObject`

Objekty `AtkObject` jsou potomci `GObjects` a všechny objekty `GObjects` potřebují specifikovat funkci `get_type()`. Zde je příklad, který nastavuje třídu a instanci inicializátoru. Tato funkce `get_type()` rovněž definuje, že objektu implementuje `ATK_TEXT`, a definuje, že rodičovský objekt bude `MYATKIMP_MYPARENTTYPE`.

###### Ukázková implementace `get_type()`

    GType
    myatkimp_mytype_get_type (void)
    {
       static GType type = 0;

       if (!type)
       {
          static const GTypeInfo tinfo =
          {
             sizeof (GailLabelClass),
             (GBaseInitFunc) NULL,                              /* base init */
             (GBaseFinalizeFunc) NULL,                          /* base finalize */
             (GClassInitFunc) myatkimp_mytype_class_init,       /* class init */
             (GClassFinalizeFunc) NULL,                         /* class finalize */
             NULL,                                              /* class data */
             sizeof (GailLabel),                                /* instance size */
             0,                                                 /* nb preallocs */
             (GInstanceInitFunc) myatkimp_mytype_instance_init, /* instance init */
             NULL                                               /* value table */
          };

          /* Set up atk_text_info structure used below */
          static const GInterfaceInfo atk_text_info =
          {
             (GInterfaceInitFunc) atk_text_interface_init,
             (GInterfaceFinalizeFunc) NULL,
             NULL
          };

          /* Set up typename and specify parent type */
          type = g_type_register_static (MYATKIMP_MYPARENTTYPE,
                "MyatkimpMytype", &tinfo, 0);

          /* This class implements interface ATK_TYPE_TEXT */
          g_type_add_interface_static (type, ATK_TYPE_TEXT,
                                       &atk_text_info);
       }
       return type;
    }

##### Inicializace třídy/instance

Budete muset vytvořit inicializátor třídy pro objekt `GObject`, pokud vaše implementace `AtkObject` buď:

1. Znovu definuje kterákoliv volání funkcí definovaná v rodiči objektu. To je typicky nutné, když některý objekt potřebuje implementovat funkci, jako je `atk_object_get_n_accessible_children()`. To je nutné, když má objekt potomka, ale ten není reprezentován widgetem.

   Například, když implementace ATK protřebuje přepsat funkci `get_name()` v `AtkObject`, vypadala by inicializace třídy nějak takto:

   ###### Inicializace třídy, která přepisuje rodičovskou funkci `get_name()`

       myatkimp_mytype_class_init (GailLabelClass *klass)
       {
         AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
         class->get_name = myatkimp_mytype_get_name;
       }

2. Vyžaduje funkci `parent->init`, `parent->notify_gtk` nebo `parent->finalize`. Tento příklad definuje všechny tři:

   ###### Inicializátor třídy, který definuje své vlastní funkce `init()`, `notify_gtk()` a `finalize()`

       static ParentObjectType *parent_class = NULL;

       myatkimp_mytype_class_init (GailLabelClass *klass)
       {
          ParentObjectType *parent_class = (ParentObjectType*)klass;

          /*
           * Caching the parent_class is necessary if the init,
           * notify_gtk, or finalize functions are set up.
           */
           parent_class = g_type_class_ref (MYATKIMP_TYPE_PARENT);

           parent_class->init = myatkimp_mytype_widget_init;
           parent_class->notify_gtk = myatkimp_mytype_real_notify_gtk;
           parent_class->finalize = myatkimp_mytype_finalize;
       }

   1. parent->init

      Funkce `parent->init()` může být nutná, když implementace ATK potřebuje udělat něco z následujícího:

      1. Ukládat do mezipaměti data získaná z widgetu GTK v pozadí.

      2. Naslouchat signálům z widgetu GTK v pozadí.

      Zde je příklad obojího:

      ###### Vlastní funkce `init()`

          void
          gail_tree_view_widget_init (MyatkimpMytype  *mytype,
                                      GtkWidget       *gtk_widget)
          {
             /* Make sure to call the parent's init function */
             parent_class->init (widget, gtk_widget);

             /* Cache a value in the ATK implementation */
             mytype->cached_value = gtk_widget_function_call();

             /* Listen to a signal */
             gtk_signal_connect (GTK_OBJECT (gtk_widget),
                                 "signal-type",
                                 GTK_SIGNAL_FUNC (_myatkimp_mytype_signal_type),
                                 NULL);
          }

      Když by byl v tomto příkladu zadaný signál `signal-type` vygenerován z `gtk_widget` v pozadí, byla by pak zavolána funkce `_myatkimp_mytype_signal_type()`.

   2. parent->notify_gtk

      Když implementace ATK potřebuje naslouchat upozornění na nějakou vlastnost u objektu GTK v pozadí, může být nutná funkce `parent->notify_gtk()`. Například:

      ###### Vlastní funkce `notify_gtk()`

          void
          myatkimp_mytype_real_notify_gtk (GObject    *obj,
                                           GParamSpec *pspec)
          {
             GtkWidget *widget = GTK_WIDGET (obj);
             AtkObject* atk_obj = gtk_widget_get_accessible (widget);

             if (strcmp (pspec->name, "property-of-interest") == 0)
             {
                /* Handle the property change. */
             }
             else
             {
                parent_class->notify_gtk (obj, pspec);
             }
          }

   3. parent->finalize

      Když je potřeba uvolnit některá data při zničení instance `GObject`, pak je potřeba funkce `finalize()` k uvolnění paměti: Například:

      ###### Vlastní funkce `finalize()`

          void
          myatkimp_mytype_finalize (GObject *object)
          {
             MyAtkimpMyType *my_type = MYATKIMP_MYTYPE (object);

             g_object_unref (my_type->cached_value);
             G_OBJECT_CLASS (parent_class)->finalize (object);
          }

### Jak zajistit zpřístupnění vlastních komponent

Přidání podpory ATK do vašeho vlastního widgetu zajistí jeho spolupráci s infrastrukturou zpřístupnění. Zde jsou obecné kroky, které jsou nutné:

- vyhodnotit vlastní widget podle pravidel v Příručce k uživatelskému rozhraní

- určit, která rozhraní ATK by měl vlastní widget implementovat, s ohledem na množinu vlastnosí widgetu a funkci

- vyhodnotit, která rozhraní ATK mohou být zděděna z třídy rodičovského widgetu

- implementovat příslušná rozhraní ATK pro třídu widgetu jedním ze dvou způsobů:

  - přímo vlastním widgetem nebo

  - v podtypu `AtkObject` vytvořeném novou podtřídou `AtkObjectFactory`

  Pokud je použita druhá metoda, musí být za běhu pomocí `AtkObjectFactoryRegistry` zaregistrován typ generátoru.

Zdrojový kód GAIL poskytuje skvělou výuku pro pokročilé používání ATK.

### Pokyny k uživatelskému rozhraní ohledně podpory zpřístupnění

Když navrhujete uživatelské rozhraní své aplikace, je zde několik jednoduchých zásad, kterých byste se měli držet, abyste zajistili, že bude použitelné pro tak široký okruhem uživatelů, jak jen to je možné, ať už spolu s asistenčními technologiemi nebo bez nich. Nenechte se zmást pocitem, že to „děláte jen pro lidi se zdravotním postižením“, a protože víte, že takováto osoba nebude vaši aplikaci nikdy používat, nemusíte se tím zabývat. Následující zásady vylepší použitelnost vaší aplikace celkově pro všechny, kdo ji budou používat – včetně vás!

#### Obecné

Všichni býváme znechucení, když nemůžeme v aplikaci najít některou funkci nebo se spleteme, což nás stojí pár minut to napravit, pokud to napravit je možné. Pokud máte nějaký typ postižení, jsou šance na potřebu věnovat více úsilí a přijít o čas podstatně vyšší. Následujících několik základních obecných zásad pomůže předejít těmto situacím pro všechny uživatele.

- Poskytněte funkci „Zpět“ pro všechny činnosti, které mění uživatelova data nebo nastavení aplikace. Pokud je to možné, nabídněte více úrovní pro funkce zpět a znovu a seznam s historií, kde uživatel získá přehled, které činnosti se budou vracet zpět.

- Poskytněte příkazy pro obnovení výchozích nastavení. Pokud některé konkrétní nastavení může způsobit úplnou nepoužitelnost aplikace pro uživatele, např. nastavení příliš malého písma, bylo by vhodnější poskytnout možnost obnovit výchozí nastavení někde mimo vlastní aplikaci. Například se to dá provést přepínačem příkazového řádku.

- Pomozte uživatelům vyvarovat se nesprávných věcí. To je důležité zejména pro činnosti, které mohou být provedné nechtěně (např. myší) nebo je nelze snadno vrátit zpět (např. přepsaný soubor). Zvažte použití potvrzovacího dialogového okna nebo přinucení uživatele přepnout se do určitého režimu, když se chystá provést potenciálně destruktivní činnost.

- Omezte zátěž uživatele na zapamatování si věcí. Například umožněte uživateli zobrazit si naráz více dokumentů a zajistěte, že nápověda nebo jiné informace mohou být vidět i během postupu, který popisují. Umožněte uživatelům kopírovat libovolné informace, které jsou zobrazené, a vložit je kamkoliv, kde lze zadávat data.

- Nenuťte uživatele vkládat disky. V závislosti na uživatelově konkrétním postižení může pro něj být fyzicky obtížné vložit nebo vyměnit disk, nebo pro něj může být obtížné zjistit, o který disk se jedná. Pokud je vaše aplikace instalována z disku CD, nabídněte možnost zkopírovat všechny soubory, které budou zapotřebí, na uživatelův pevný disk.

- Neumisťujte často používané funkce hluboko do struktury nabídky. Ať už používáte myš, klávesnici nebo jiné vstupní zařízení, je lepší se hluboce vnořeným položkám v nabídkách vyhnout. Mimo to, že je obtížne si zapamatovat, kde je najdete, je vždy také časově náročné se k nim dostat.

- Neveďte uživatele kroky, které nejsou nutné. Například, průvodci jsou užiteční pro uživatele, kteří mají problém pracovat s velkým množstvím různých voleb naráz, ale jiní uživatelé třeba potřebují ušetřit čas nebo počet zmáčknutí kláves. Tito uživatelé těží výhodu z možnosti přeskočit nepotřebné kroky nebo z možnosti přejít přímo na ten, který potřebují. Zvažte v průvodci nabídnutí tlačítka Dokončit, které přeskočí zbývající kroky do konce a bude pro ně předpokládat výchozí odpovědi. Pokud má proces mnoho kroků, zvažte, zda se na začátku uživatele nezeptat, jestli chce projít všemi kroky nebo jen těmi nejběžnějšími.

#### Ovládání klávesnicí

Dobře navržené klávesnicové uživatelské rozhraní hraje klíčovou roli, když navrhujete přístupný software. Slepí uživatelé dokáží software lépe obsluhovat pomocí klávesnice, protože ovládání myší závisí na vizuální zpětné vazbě vůči poloze ukazatele myši. Také pohybová postižení mohou uživateli bránit v úspěšné obsluze myší, protože to vyžaduje schopnost jemného motorického ovládání.

Proto je důležité umožnit všechny činnosti prováděné myší provést i pomocí klávesnice, včetně přístupu z klávesnice ke všem nástrojovým lištám, nabídkám, odkazům a tlačítkům. Každá funkce, kterou vaše aplikace nabízí, by měla být dostupná čistě pomocí klávesnice. Pokud musíte, skryjte si během testování své aplikace myš!

Většina funkcionality by měla být snadno přístupná pomocí horkých kláves a klávesových zkratek a pomocí funkcí ovládání zabudovaných v nástrojové sadě, na které je aplikace vyvíjena. Nicméně nad některými operacemi, jako „táhni a upusť“, se budete muset zamyslet hlouběji.

- Poskytněte účinný přístup z klávesnice ke všem funkcím aplikace. Někteří uživatelé nemusí být schopní používat myš a řada pokročilých uživatelů dává tak jako tak přednost klávesnici. Také některá specializovaná zařízení asistenčních technologií mohou simulovat spíše události od klávesnice než od myši. Protože pro některé uživatele je psaní náročně nebo až bolestivé, je důležité nabídnout uživatelské rozhraní, které minimalizuje počet zmáčknutí kláves pro libovolný účel.

- Použijte logické pořadí pro obsluhu klávesnicí. Když se pohybujete po okně pomocí klávesy Tab, měly by se ovládací prvky zaměřovat v předvídatelném pořadí. V národních prostředích západní civilizace to normálně je zleva doprava a shora dolů.

- Zajistěte správné pořadí pro ovládání klávesou Tabulátor u ovládacích prvků, které se aktivují zaškrtávacím políčkem, skupinovým přepínačem nebo přepínacím tlačítkem. Když je se takovýmto prvkem provede aktivace, všechny závislé ovládací prvky se aktivují naopak ovládací prvky závislé na ostatních přepínacích prvcích ve skupině se deaktivují. Když uživatel vybere zaškrtávací políčko, skupinový přepínač nebo přepínací tlačítko, které mají závislé ovládací prvky, nepřesouvejte automaticky zaměření na první závislý ovládací prvek, ale ponechte zaměřený ten, který uživatel vybral.

- Nepřepisujte funkce zpřístupnění již existující na úrovní systému. Například AccessX je rozšíření pro Xserver, které je podporováno od X11R6. Funkce MouseKeys (myš z klávesnice) v tomto rozšíření umožňuje pohyb myši a kliknutí jejích tlačítek simulovat pomocí číselné klávesnice. Proto byste neměli přidávat do své aplikace funkce, které jsou přístupné jen zmáčknutím kláves na číselné klávesnici, protože uživatelé spoléhající na funkci MouseKeys je nebudou moci použít.

- Pokud je to možné, nabídněte pro klávesnicové činnosti více variant. Pro některé uživatele mohou být některé klávesy a kombinace kláves snadnější na použití než jiné.

- Pokud je to možné, poskytněte přístup k funkcím jak z klávesnice, tak myší. Někteří uživatelé mohou být schopní používat buď jen myš nebo jen klávesnici, ale ne obojí.

- Nepřiřazujte nepříjemně dosažitelné kombinace často prováděným činnostem na klávesnici. Někteří lidé mohou být schopní používat na klávesnici jen jednu ruku, takže je pro běžné operace třeba dávat přednost klávesovým zkratkám, které se dají snadno provést jednou rukou. Nehledě na to, že mít pro často prováděné činnosti na klávesnici klávesy daleko od sebe nebo špatně dosažitelné, zvyšuje napětí svalů u všech uživatelů a tím i riziko bolesti a zdravotních komplikací.

- Nepožadujte opakované použití současného zmáčknutí více kláves. Někteří uživatelé jsou schopní v jednu chvíli zmáčknout a držet jen jednu klávesu. Asistenční technologie, jako je AccessX, mohou uživateli umožnit zmáčknout klávesy po sobě, místo naráz, to ale samozřejmě znamená, že operace zabere více času.

- Ujistěte se, že kterýkoliv text, který lze vybrat pomocí myši, je možné vybrat i pomocí klávesnice. To je výhodné pro všechny uživatele, ale zvláště pro ty, kterým činí obtíže přesné ovládání myši.

- Ujistěte se, že objekty, u kterých lze měnit velikost nebo je přesouvat, to lze provést i pomocí klávesnice. Například ikony a okna na pracovní ploše. Tam kde je potenciálně důležitá přesná změna velikosti nebo umístění, např. útvary v diagramu, zvažte také poskytnutí dialogového okna, ve kterém půjdou zadat souřadnice a rozměry číselně, nebo promyslete přichytávání objektů k uživatelem definované mřížce.

- Nepoužívejte obecné ovládací funkce ke spouštění činnosti. Například, nesnažte se použít ovládání klávesou Tab v dialogovém okně k aktivaci nějaké činnosti související s ovládacím prvkem.

- Zobrazujte klávesnicí vyvolané nabídky, okna a vysvětlivky blízko objektu, ke kterému se vztahují. V GNOME 2 mohou uživatelé vyvolat vyskakovací nabídky pomocí Shift F10 a vysvětlivky pomocí Shift F1. Pozor však, ať objekt, na který se nabídky nebo vysvětlivka odkazují, zcela nebo i jen částečně nezakryjete.

#### Spolupráce s myší

Pamatujte, že ne každý může používat myš se stejnou obratností a že někteří uživatelé mohou mít problém sledovat ukazatel myši.

- Nevytvářejte závislost na vstupu z tlačítek 2 a 3 u myši. Jednak bývá fyzicky náročnější je zmáčknout a jednak některá ukazovací zařízení a řada zařízení pro asistenční technologie podporuje jen tlačítko 1. Některé asistenční technologie nemusí emulovat myš vůbec, ale generují místo ní události od klávesnice.

- Poskytněte možnost všechny operace s myší přerušit. Zmáčknutí klávesy Esc by mělo přerušit kteroukoliv operaci myší, která probíhá, jako třeba přetahování souboru ve správci souborů nebo přetahování útvaru v kreslícím programu.

- Během operace táhni a upusť poskytněte zpětnou vizuální odezvu. Když myš dosáhne použitelného cíle, zvýrazněte jej a změňte ukazatel myši. Použijte ukazatel myši „nelze upustit“, když se přejíždí přes nepoužitelný cíl. Viz Příklady spolupráce s myší.

- Nezakrývejte ukazatel myši nebo neomezujte pohyb myši jen na část obrazovky. Může se to křížit s asistenčními technologiemi a obvykle to mate i uživatele, kteří na nich nejsou závislí.

- Nevytvářejte příliš malé cíle pro myš. Obecně by cíle myši měly mít přinejmenším velikost „horké oblasti“ okolo okraje okna pro změnu velikosti v aktuálním okenním správci/motivu – s ohledem na to, že uživatel s poruchou zraku nebo pohyblivosti může používat okenního správce s širší oblastí, než je výchozí.

##### Příklady spolupráce s myší

###### Příklad ukazatele „nelze upustit“ z CDE/Motif

Příklad podoby ukazatele „nelze upustit“

#### Grafické prvky

Poskytněte volbu k přizpůsobení prezentace všech podstatných grafických prvků ve své aplikaci. Díky tomu bude její používání snadnější pro lidí, kteří mají zrakové nebo pohybové postižení.

- Nevkládejte do kódu napevno vlastnosti grafiky, jako je tloušťka čar, okraje nebo stíny. Tyto prvky by ideálně měly být načítány z motivu GTK nebo z okenního správce. Pokud to není možné, nabídněte volbu změny přímo ve své aplikaci.

- Poskytněte popisné názvy pro všechny prvky rozhraní. Knihovna GAIL poskytuje výchozí zpřístupňující popisy pro řadu widgetů GTK, ale i tak budete potřebovat v některých případech přidat své vlastní, třeba pro widgety, které používají grafiku místo textu (např. v barevné paletě nebo v ikoně bez popisku). Jestli je to možné, zvažte přepsání výchozího popisu nějakým názornějším nebo popisem specifickým pro aplikaci.

- Pokud je to možné, umožněte vícebarevné grafické prvky (např. ikony na nástrojové liště) zobrazit jen monochromaticky. Tyto monochromatické obrázky by měly být zobrazeny v barvách popředí a pozadí, které si uživatel sám zvolí v nastavení systému (výběrem motivu GTK), aby dosáhl pro něj nejlepší čitelnosti.

- Zajistěte, aby interaktivní prvky grafického rozhraní byly snadno rozpoznatelné. Například, nenuťte uživatele najíždět myší na objekt, aby zjistil, jestli se na něj dá kliknout či nikoliv. Ponechávejte mezi objekty dostatek místa a jasně vymezte jejich hranice. Nezobrazujte prvky grafického rozhraní, které sice vypadají hezky, ale ve skutečnosti nic nedělají, a když už ano, nabídněte volbu je vypnout.

- Poskytněte volbu ke skrytí grafiky, která nevyjadřuje žádné podstatné informace. Grafické obrázky mohou být rušivé pro uživatele s některými poruchami rozpoznávání. Například lze vypnout ikony v nabídkách GNOME a funkčnost nabídek přitom zůstane zachována.

#### Písma a text

Dokonce i pro uživatele s normálním zrakem poskytují textové výstupy většinu informací a zpětné odezvy ve většině aplikací. Je proto rozhodující správně zvolit a umístit text na obrazovce a ponechat volbu písma a jeho velikosti na uživateli, aby se i uživatelům se zrakovým postižením poskytla možnost aplikaci plně používat.

- Neurčujte napevno styl a velikost písma. Uživatel by měl mít možnost přizpůsobit si u všech textů velikost a typ písma. Pokud z nějakého důvodu tuto funkčnost nemůžete nabídnout, nikdy napevno nezadávejte menší velikost než 10 bodů.

- Poskytněte volbu vypnout grafické doplňky a „vodoznaky“ za textem. Takové obrázky narušují kontrast mezi textem a pozadím, což může způsobit obtíže pro uživatele se zrakovým postižením.

- Popisky objektů mají mít názvy, které mají smysl, i když jsou vytržené z kontextu. Uživatelé spoléhající na čtečku obrazovky nebo podobné asistenční technologie nemusí být ihned schopni pochopit vztah mezi ovládacím prvkem a věcmi, které jej obklopují.

- Nepoužívejte stejný popisek v jednom okně vícekrát. Když použijete stejný popisek v různých oknech, pomůže, když bude mít v obou dvou stejný význam. Rovněž nepoužívejte v jednom okně popisky, které se sice jinak píší, ale stejně znějí. Např. v angličtině „read“ a „red“ nebo v češtině „správa“ a „zpráva“, protože to může být matoucí pro uživatele spoléhající na čtečku obrazovky.

- Umisťujte popisky v celé aplikaci stejným způsobem. Normálně to bývá přímo pod velkými ikonami, napravo hned vedle malých ikon a přímo nad nebo nalevo od ovládacích prvků. Viz Příklady písem a textů.

- Když použijete v popisku pro ovládací prvek statický text, zakončete jej dvojtečkou. Například Uživatelské jméno: v popisku pro textové pole, do kterého má uživatel napsat své uživatelské jméno. Pomůže to rozpoznat, že popisek není samostatný, ale patří k ovládacímu prvku.

- Když používáte statický text jako popisek pro ovládací prvek, nastavte popisek tak, aby bezprostředně předcházel ovládacímu prvku v pořadí ovládání klávesou Tab. To zajistí, že horká (mneomotechnická) klávesa, kterou v popisku pomocí podtržítka nadefinujete, způsobí při zmáčknutí zaměření nebo aktivaci správného ovládacího prvku.

- Poskytujte alternativu k WYSIWYG (přesnému grafickému zobrazení výsledné podoby). Například někteří uživatelé mohou potřebovat tisknout text malým písmem, ale upravovat jej s velkým písmem. Možné alternativy zahrnují zobrazení veškerého textu stejným písmem ve stejné velikosti (obojí podle výběru uživatele), volbu „zalamování do okna“, která umožní uživatelům číst všechen text bez nutnosti vodorovného posouvání, jednosloupcové zobrazení, které zobrazuje obsah okna v jediném sloupci, i když vytisknut bude ve více sloupcích, a čistě textové zobrazení, kdy je grafika nahrazena zástupnými objekty nebo popisným textem. Pokud má aplikace panely s podřízenými ovládacími prvky, zvažte umožnit roztáhnout je přes celé rodičovské okno.

##### Příklady s písmy a texty

###### Správné umístění popisků pro různé prvky GUI

List control with label above Ovládací prvek seznam s popiskem nad sebou | Large file manager icon with label underneath Velká ikona správce souborů s ikonou pod sebou | Small toolbar icon with label to its right Malá ikona nástrojové lišty s popiskem po své pravé straně | Spinbox control with label to its left Ovládací prvek číselník s popiskem po své levé straně

#### Barvy a kontrast

Špatný výběr barev pro zobrazení může způsobit problémy lidem s barvoslepostí (pro ně je důležitý odstín barvy) nebo slabozrakostí (pro ně je důležitý jas/kontrast). Obecně byste měli umožnit uživatelům přizpůsobit si barvy kterékoliv části aplikace, která poskytuje podstatné informace.

Uživatelé se zrakovým postižením mohou požadovat vysoký kontrast mezi pozadím a barvou textu. Často je používáno černé pozadí a bílý text, aby se předešlo přepalování. Tato nastavení jsou rozhodující pro uživatele se zrakovým postižením.

- Nezadávejte do aplikace napevno barvy. Někteří uživatelé potřebují používat určité kombinace barev a úrovně kontrastu, aby dokázali pohodlně číst obrazovku. Z toho důvodu by měly být hlavní barvy požívané ve vaší aplikaci pro GNOME přebírány z motivu GTK, takže si uživatelé mohou nastavit barvy pro všechny své aplikace na něco čitelnějšího pouhou změnou motivu. Pokud z nějakého důvodu potřebujete použít barvu, která není dostupná v motivu, zajistěte, aby byla nastavitelná v rámci aplikace.

- Nepoužívajte barvu jako jediné znázornění významu položky. Všechny informace by měly být poskytovány nejméně jedním dalším způsobem, třeba tvarem, polohou nebo textovým popisem. Viz Příklady s barvami a kontrastem.

- Podporujte všechny motivy GNOME s vysokým kontrastem. Ujistěte se, že když jeden z těchto motivů vyberete, bude všechen text ve vaší aplikaci ve vysokém kontrastu mezi barvou popředí a pozadí daného motivu.

- Zajistěte, aby vaše aplikace nebyla závislá na konkrétním motivu s vysokým kontrastem. Otestujte ji s různými motivy s vysokým kontrastem, abyste měli jistotu, že aplikace respektuje nastavení.

##### Příklady s barvami a kontrastem

###### Příklad ukazující zdvojené použití barvy

Příklad ukazuje změny v cenách akcií jen pomocí barvy | Takovéto zobrazení může způsobit problémy barvoslepým uživatelům, kteří nerozeznají červenou od zelené (barvoslepost postihuje v některých zemích až 1 ze 7 mužů). Nedostatečný kontrast mezi červeným textem a černým pozadím by rovněž mohl ztížit čtení některým slabozrakým uživatelům, i když použijí lupu obrazovky.
Příklad ukazuje změny v cenách akcií současně pomocí barvy a šipek | Takovéto zobrazení vylepšuje barevné rozlišení ještě šipkami, které naznačují směr pohybu ceny akcií, a používá tmavší odstíny zelené a červené na světlejším pozadí, aby se zajistil větší kontrast. Nemusí jít o výchozí barevné schéma, pokud by testování ukázalo, že na většinu uživatelů působí příliš rušivě, ale mělo by být možné si jej přizpůsobit, buď pomocí motivů nebo v dialogovém okně Předvolby v dané aplikaci.

#### Lupa

Z výhod zvětšení textu a grafiky může těžit spousta uživatelů, i když nemají zrakové postižení. Ale bez možnosti zvětšení nebudou uživatelé se zrakovým postižením moci program vůbec používat.

- Poskytněte uživateli možnost přiblížit si pracovní oblast.

- Poskytněte v aplikaci volbu přiblížení/oddálení pracovní oblasti. Uživatelé potřebují v nabídce přiblížení pracovní oblasti 150 % až 400 % nebo více. Otestujte aplikaci, abyste ověřili, že zobrazené objekty nebudou změnou přiblížení nějak postiženy.

#### Zvuk

Lidé, kteří mají problém se sluchem, stejně jako lidé, kteří pracují na počítači s vypnutým zvukem, budou znevýhodněni, když vaše aplikace bude spoléhat na zvuk, jako jediný prostředek sdělení informace. Obecně, zajistěte, aby uživatelé mohli získat zvukové informace i jiným vhodným způsobem.

- Nepředpokládejte, že uživatel uslyší zvukové informace. Nemusí jít jen o zvukové postižení uživatele, stačí, když bude mít vadnou zvukovou kartu.

- Nepoužívejte zvuk jako jediný prostředek sdělení informace. Dejte uživateli možnost volby mít všechny zvukové informace i ve vizuální podobě. Zahrnuje to poskytování titulků nebo přepisů pro všechny důležité mluvené zvukové klipy.

- Umožněte uživatelům nastavit si frekvenci a hlasitost všech varovných pípnutí a dalších zvuků. Včetně možnosti vypnout naráz všechny zvuky.

#### Animace

Když se animace používají přiměřeně, mohou být užitečné pro zdůraznění důležitých informací ve vaší aplikaci – a navíc mohou vypadat dobře. Mohou ale působit potíže některým uživatelům, takže zajistěte, aby šly vypnout.

- Nepoužívejte blikání prvků s frekvencí větší net 2 Hz a nižší než 55 Hz. To platí jak pro text, tak pro grafické objekty. Cokoliv v tomto rozsahu frekvencí může způsobit problémy uživatelům s vjemově vyvolávanými záchvaty. Poznamenejme ale, že neexistuje žádná „bezpečná“ frekvence. U blikání je podstatné, že byste měli použít frekvenci blikání systémového kurzoru (kterou si uživatel může přizpůsobit), nebo umožnit uživateli si ji upravit v aplikaci.

- Neblikejte velkými plochami obrazovky. U menší oblasti je méně pravděpodobné že spustí záchvat u lidí, kteří jsou na záchvaty náchylní.

- Všechny animace ponechte volitelné. Všechny informace podávané animací by měly být na uživatelův požadavek dostupné nejméně jedním jiným způsobem.

#### Zaměření klávesnicí

Jasné označení místa zaměřeného klávesnicí je vždy důležité, jak pro uživatele se zrakovým postižením, tak pro „pokročilé“ uživatele, kteří dávají přednost ovládání z klávesnice před myší. Nikdy by neměli být zmateni tím, který ovládací prvek na pracovní ploše je zrovna zaměřený. Neměli byste mít problém opustit počítače s ponecháním zaměření na některém widgetu v aplikaci, jít někam pryč, zatelefonovat přítelkyni, vyvenčit psa a při tom všem zapomenout, který prvek byl zaměřen a až se vrátíte, měli byste okamžitě dokázat poznat, který widget to je.

Indikátor vizuálního zaměření je zvukovou podobou pozice kurzoru relativně vůči ostatním objektům v pracovním prostředí. Díky tomu se uživatel může pohybovat interaktivně okolo objektů tak, jak se mění zaměření. Vizuální zaměření musí být programově oznamováno asistenčním technologiím. Poznamenejme ale, že ve většině případů se tak děje automaticky pomocí ATK, aniž byste pro to museli něco udělat. Musíte ale tomuto požadavku například věnovat pozornost, když píšete svůj vlastní widget.

- Začněte se zaměřením nejčastěji používaného ovládacího prvku. Pokud nelze o žádném ovládacím prvku v okně říct, že by byl „nejčastěji“ používaný, začněte po otevření okna se zaměřením na prvním ovládacím prvku. Zaměření by nemělo začínat na tlačítkách Budiž nebo Zrušit v dialogovém okně, i když jsou nejčastěji používané, protože je lze vždy aktivovat bezprostředně zmáčknutím Enter nebo Esc.

- Vždy jasně zobrazujte aktuální zaměření vstupu. Pamatujte, že v ovládacích prvcích, které obsahují posuvníky, nemusí stačit zvýraznit jen pravě vybraný prvek uvnitř posouvané oblasti, protože nemusí být zrovna vidět. Viz Příklady zaměření klávesnicí.

- Zobrazujte zaměření vstupu jen v aktivním okně. Všechny primární vizuální ukazatele zaměření v oknech, které nemají zaměření a nejsou aktivní, skryjte. Když má jedno okno oddělené panely, jen jeden z nich by měl mít indikátor zaměření a v ostatních panelech by měly být skryty. Pokud je důležité zobrazovat, která položka je v nezaměřených seznamem vybrána, použijte například druhotný indikátor zaměření. Viz Příklady zaměření klávesnicí.

- Poskytněte uživateli vhodnou zpětnou vazbu, když se pokusí dostat za konec skupiny souvisejících objektů. Například při cyklickém pohybu v seznamu je při přesunu zaměření zpět na první objekt v seznamu často používána zpětná vazba v podobě zastavení se zvukovým upozorněním. V opačném případě by slepí nebo slabozrací uživatelé netušili, že se vrátili na začátek. V případě vyhledávání textu v dokumentu můžete zobrazit dialogové okno, které upozorní na dosažení konce dokumentu a dotáže se, jestli chce uživatel pokračovat s hledáním od začátku dokumentu.

- Když uživatel zmáčkne nevhodnou klávesu nebo když navigační klávesa selže v provedení pohybu na zaměřeném prvku, přehrajte výchozí systémový zvukový nebo vizuální signál pro varování. Například, když je zaměřen první znak v textovém poli a uživatel zmáčkne kurzorovou šipku doleva nebo když se uživatel pokusí vybrat více v souborů v dialogovém okně pro výběr jednoho souboru. (Poznamenejme, že uživatel se sluchovým postižením by měl mít možnost si v systému nastavit vizuální náhradu výchozího zvukového varování.)

##### Příklady zaměření klávesnice

###### Příklady ukazují nutnost jasného zobrazení zaměření

Zaměřenou položku v tomto okně nemůžete vidět, protože je posunutá mimo obrazovku | Jeden ovládací prvek v tomto okně má zaměření, ale není možné říci který…
Zaměřená položka se posuvem dostala do viditelné části | …dokud se seznam neposune, čímž se právě vybraná položka odhalí.
Ovládací prvek seznam v tomto příkladu má plné ohraničení, který signalizuje zaměření, ať už je vybraná položka vidět nebo ne | Když má přímo ovládací prvek se seznamem ohraničení „zaměřeno“, lze jednoduše říci, že je zaměřený, i když právě vybraná položka není vidět.

###### Ilustrační příklad používající druhotné zaměření

Okno rozdělené na panely, kdy oba panely vypadají, že mají zaměření | V tomto příkladu není možné říci jen po pouhém pohledu, který ze dvou panelů má právě zaměření klávesnice.
Okno rozdělené na panely, kdy druhotné zvýraznění je použito k zobrazení, který panel má zaměření | Díky použití druhotného barevného zvýraznění výběru v neaktivním panelu, je ihned jasné, že zde má zaměření ovládací prvek se stromem…
Okno rozdělené na panely, kdy druhotné zvýraznění je použito k zobrazení, který panel má zaměření | … a zde má zaměření ovládací prvek se seznamem.

#### Načasování

Uživatelská rozhraní, ve kterých se věci objevují, mizí nebo se dějí podle časových omezení napevno daných v kódu, jsou často překážkou v přístupnosti. Někteří uživatelé mohou číst, psát a reagovat jen velmi pomalu v porovnání s ostatními lidmi. Když se jim nějaká informace skryje dřív, než jsou s ní hotovi, nebo ji překryje jiná informace, kterou si výslovně nevyžádali, stává se pro ně použití aplikace velmi frustrující, ne-li nemožné.

- Nezadávejte časová omezení a jiné na čase závislé funkce napevno do kódu. Příklady budiž automatický posuv při tažení objektu k okraji okna, držení tlačítka posuvníku nebo automatické rozbalení uzlu ve stromu, když je přes něj tažen objekt a chvilku podržen na místě. Mělo by to být přizpůsobitelné buď přímo v aplikaci nebo v ovládacím centru GNOME nebo, jako nejhorší varianta, aspoň ručně z příkazového řádku záznamem v souboru s nastavením nebo v GConf.

- Nezobrazujte a neskrývejte informace jen na okamžik v závislosti na pohybu ukazatelem myši. (Výjimka: funkce poskytované systémem, jako jsou vysvětlivky, které si může uživatel na úrovni systému nastavit). Pokud takové funkce musíte poskytovat, nabídněte k nim volbu je vypnout, když je nainstalován nástroj pro zkoumání obrazovky.

#### Dokumentace

Lidé s postižením nemohou používat aplikaci plně, když nemají přístup k potřebným příručkám a nápovědě. Podstatnou věcí je ovládání z klávesnice, protože pro řadu uživatelů to může být jediný způsob ovládání aplikace.

- Poskytněte veškerou dokumentaci v přístupném formátu. ASCII a HTML jsou skvělé formáty pro asistenční technologie.

- Ke všem grafickým prvkům v dokumentaci poskytněte alternativní textový popis.

- Zdokumentujte všechny funkce zpřístupnění ve své aplikaci. Ovládání klávesnicí a klávesové zkratky jsou zvláště důležitou věcí ke zdokumentování. Zahrňte do své dokumentace kapitolu o zpřístupnění, ve které bude možné najít všechny informace o funkcích zpřístupnění.

## Testování

Je několik věcí, které by měly být prověřeny, než je možné aplikaci prohlásit za přístupnou. V průběhu vývoje možná budete uvažovat o automatických testovacích technikách. Váš plán automatizovaných testů by mohlo doplnit například LDTP.

Tato část popisuje řadu testů, které můžete u aplikace provést ručně, abyste odzkoušeli její zpřístupnění. To, že všechny testy projdou, ještě nutně neznamená, že aplikace je plně zpřístupněná, ale pokud naopak v některém z testů selže, bude potřeba další práce, aby se zdokonalila z hlediska zpřístupnění.

### Ovládání klávesnicí

Otestovány by měly být následující operace z klávesnice. V žádné části z těchto testů nepoužívejte myš.

- Jen pomocí klávesnice projděte zaměřením všechny položky v nabídkové liště aplikace.

- Ujistěte se, že:

  - Kontextově citlivé nabídky se zobrazují správně.

  - Libovolné funkce uvedené na nástrojové liště lze provést i pomocí klávesnice.

  - Můžete použít všechny ovládací prvky v klientské části aplikace a v dialogových oknech.

  - Text a objekty v klientské oblasti je možné vybrat.

  - Vylepšené ovládání klávesnicí nebo klávesové zkratky fungují, jak mají.

### Grafické prvky

Otestujte aplikaci pomocí čtečky obrazovky a ujistěte se, že:

- Popisky a text jsou správně čteny, včetně nabídek a nástrojových lišt.

- Informace o objektu jsou správně čteny.

### Vizuální indikátor zaměření

- Ověřte, že když se posouváte podél objektů, které mají indikátor vizuálního zaměření, je snadné je rozpoznat.

- Při ovládání softwaru a nabídek klávesnicí by měl být jasně viditelné, kam se přesouvá zaměření.

- Ověřte, že čtečka obrazovky sleduje indikátor vizuální zaměření tak, jak se pohybujete pomocí klávesnice.

- Spusťte lupu obrazovky (pokud je k dispozici) a ověřte, že lupa sleduje indikátor vizuálního zaměření tak, jak se pohybujete pomocí klávesnice.

### Písma a text

- Změňte v aplikaci písmo a ověřte si, že nastavení je použitelné.

- Otestujte aplikaci změnou barev a ověřte si, že nastavení je použitelné.

- Když je k dispozici zvětšení, otestujte s ním písmo, barvu a velikost.

### Barvy a kontrast

- Vytiskněte snímek obrazovky na černobílou tiskárnu a ověřte si, že všechny informace jsou viditelné.

- Otestujte aplikaci jen v černobílém nastavení s vysokým kontrastem a ověřte, že všechny informace jsou podávány správně.

- Otestujte, že aplikace poskytuje nejméně tři kombinace barevných schémat, a že je k dispozici i schéma s vysokým kontrastem (např. bílá na černé nebo žlutá na modré).

- Zapněte v ovládacím centru GNOME vysoký kontrast a ověřte, že aplikace toto nastavení respektuje.

- Otestujte různé motivy, abyste se ujistili, že software funguje pro všechna dostupná nastavení.

### Zvuk

V aplikaci by měla být možnost zobrazit všechna zvuková upozornění vizuálně.

Povolením zvuku v ovládacím centru GNOME otestujte, že zvuk funguje správně a proveďte následující činnosti:

- Proveďte činnosti, které by měly vyvolat zvukové upozornění a ověřte, že aplikace pracuje, jak byla navržena.

- Ověřte, že aplikace funguje správně, když zvýšíte nebo snížíte hlasitost.

- Ověřte, že varovné zprávy a upozornění budou dobře slyšet i v hlučném pracovním prostředí.

### Animace

Ověřte, že je k dispozici volba k zastavení animace, a že funguje, jak má.

Vypněte animace. Ověřte, že všechny informace jsou stále podávány správně.

### Zaměření klávesnicí

- Otestujte všechny zprávy, abyste si ověřili, že uživatel je upozorněn dříve, než zpráva zmizí, a že má možnost dát najevo, že potřebuje více času.

- Ujistěte se, že je k dispozici volba pro přizpůsobení času na reagování a ověřte, že funguje, jak má.

### Dokumentace

Otestujte dokumentaci v čistě textové podobě spolu se čtečkou obrazovky a ověřte, že je asistenční technologií čtena jasně a přesně.

Otestujte dokumentaci v HTML pomocí webového prohlížeče a čtečky obrazovky, abyste se ujistili, že k dokumentaci mají přístup asistenční technologie.

Poznámka: Příručka k zpřístupnění webů je dostupná na http://www.w3.org/TR/WAI-WEBCONTENT/.

Zkontrolujte, že jsou součástí dokumentace následující informace:

- Upozornění, když aplikace nepodporuje některý ze standardních přístupů z klávesnice používaných operačním systémem.

- Vypíchnutí jedinečných klávesnicových příkazů.

- Vypíchnutí jedinečných funkcí zpřístupnění.

- Pokud je nějaká činnost zdokumentovaná pro myš, informaci o alternativě pro použití klávesnice.

### Kontrolní seznam pro uživatelské rozhraní

Tato část shrnuje pokyny dané v kapitole Pokyny k uživatelskému rozhraní ohledně podpory zpřístupnění. Když budete chtít podrobnější informace k některé z položek kontrolního seznamu, měli byste se podívat právě do této kapitoly.

Když aplikaci testujete ohledně zpřístupnění, měli byste projít všechny položky v tomto seznamu. U každé si poznačte, zda test prošel nebo selhal, případně u aplikace nemá význam.

### Kontrolní seznam pro obecné principy

OP | Obecné principy | Prošlo/Selhalo/Nepoužíváno
OP.1 | Každá činnost, která mění uživatelská data nebo nastavení aplikace by měla jít vrátit zpět.
OP.2 | Všechna nastavení aplikace by mělo být možné obnovit na výchozí hodnoty, aniž by si uživatel musel pamatovat, jaké byly.
OP.3 | Po nainstalování by aplikace měla jít používat, aniž by uživatel musel někdy vkládat disk nebo CD.
OP.4 | Nejčastěji používané funkce by se měly nacházet v horní úrovni struktury nabídek.

### Kontrolní seznam pro ovládání z klávesnice

OK | Ovládání klávesnicí | Prošlo/Selhalo/Nepoužíváno
OK.1 | Použitelný přístup z klávesnice musí být poskytnut pro všechny funkce aplikace.
OK.2 | Všechna okna musí mít logické pořadí pro ovládní z klávesnice.
OK.3 | Ovládací prvky, které jsou přístupné v závislosti na zaškrtávacím políčku, skupinovém přepínači nebo přepínacím tlačítku, mají správné pořadí pro klávesu Tab.
OK.4 | Přístup z klávesnice k funkcím týkajícím se aplikace nepřepisuje stávající systém funkcí zpřístupnění.
OK.5 | Pokud je to možné, poskytuje aplikace více než jednu metodu k provedení úloh z klávesnice.
OK.6 | Kdykoliv je to možné, je k dispozici alternativní kombinace kláves.
OK.7 | Pro často prováděné operace z klávesnice se nepoužívají žádné špatně dosažitelné klávesy.
OK.8 | Aplikace nepoužívá opakující se souběžná zmáčknutí kláves.
OK.9 | Aplikace poskytuje pro všechny funkce myši odpovídající ovládání klávesnicí.
OK.10 | Libovolný text nebo objekt, který je možné vybrat myší, musí jít vybrat i čistě pomocí klávesnice.
OK.11 | Libovolný objekt, u kterého je možné měnit velikost pomocí myši nebo jej myší přesouvat, mustí být možná změna velikosti a přesun i čistě pomocí klávesnice.
OK.12 | Aplikace nepoužívá žádné obecné ovládací funkce ke spouštění operací.
OK.13 | Všechny nabídky, okna a vysvětlivky vyvolané klávesnicí se objeví poblíž objektu, ke kterému se vztahují.

### Kontrolní seznam pro ovládání myší

SM | Spolupráce s myší | Prošlo/Selhalo/Nepoužíváno
SM.1 | Žádná operace nezávisí čistě na vstupu z pravého nebo prostředního tlačítka myši.
SM.2 | Všechny operace s myší mohou být zrušeny dřív, než jsou dokončeny.
SM.3 | Během operací táhni a upusť je poskytována zpětná vizuální vazba.
SM.4 | Ukazatel myši nikdy nezajíždí pod ovládací prvky aplikace nebo není jeho pohyb aplikací omezen jen na část obrazovky.

### Kontrolní seznam pro grafické prvky

GP | Grafické prvky | Prošlo/Selhalo/Nepoužíváno
GP.1 | Nejsou napevno zakódovány žádné grafické atributy, jako tloušťka čar, okraje nebo stíny.
GP.2 | Všechny vícebarevné grafické prvky mohou být zobrazeny čistě monochromaticky, když je zapotřebí.
GP.3 | Všechny interaktivní prvky uživatelského rozhraní musí být snadno rozlišitelné od statických prvků.
GP.4 | Je k dispozici volba pro skrytí nedůležité grafiky.

### Kontrolní seznam pro písma a texty

PT | Písma a text | Prošlo/Selhalo/Nepoužíváno
PT.1 | Žádný styl nebo velikost písma nejsou určeny natvrdo.
PT.2 | Je poskytována volba vypnout grafické pozadí pod textem.
PT.3 | Všechny popisky mají názvy, které dávají smysly, i když jsou vytržené z kontextu.
PT.4 | Žádné názvy popisků nejsou v témže okně použity vícekrát.
PT.5 | Umístění popisků je jednotné napříč celou aplikací.
PT.6 | Všechny statické textové popisky, které identifikují ostatní ovládací prvky, jsou zakončené dvojtečkou (:).
PT.7 | Všechny statické textové popisky, které identifikují ostatní ovládací prvky, se nachází před těmito ovládacími prvky v rámci pořadí přepínání tabulátorem.
PT.8 | Je poskytnuta alternativa k WYSIWIG (přesnému grafickému zobrazení výsledné podoby). Například v podobě možnosti v textovém editoru určit jinou obrazovku nebo písmo tisku.

### Kontrolní seznam pro barvy a kontrast

BC | Barvy a kontrast | Prošlo/Selhalo/Nepoužíváno
BC.1 | Žádné barvy nejsou v aplikaci určeny natvrdo, ale vychází buď z aktuálního motivu pracovního prostředí nebo se dají v aplikaci nastavit.
BC.2 | Barva je použita jen jako vylepšení a ne jako hlavní způsob sdělení významu informace nebo činnosti.
BC.3 | Aplikace podporuje všechny dostupné motivy s vysokým kontrastem a nastavení pro ně.
BC.4 | Software není závislý na konkrétním motivu s vysokým kontrastem nebo jeho nastavení.

### Kontrolní seznam pro zvětšování

ZL | Lupa | Prošlo/Selhalo/Nepoužíváno
ZL.1 | Aplikace poskytuje schopnost přiblížit pracovní oblast.
ZL.2 | Aplikace nabízí volbu pro změnu měřítka pracovní oblasti.
ZL.3 | Funkčnost aplikace není dotčena změnou zvětšení nebo nastavením přiblížení.

### Kontrolní seznam pro zvuk

ZV | Zvuk | Prošlo/Selhalo/Nepoužíváno
ZV.1 | Zvuk není jediný způsob sdělení významu nějaké části informace.
ZV.2 | Uživatel může nastavit frekvenci a hlasitost všech zvuků a varovných pípnutí.

### Kontrolní seznam pro animace

AN | Animace | Prošlo/Selhalo/Nepoužíváno
AN.1 | Nepoužívají se blikající prvky s frekvencí větší než 2 Hz a menší než 55 Hz.
AN.2 | Blikání je omezeno jen na malé části obrazovky.
AN.3 | Pokud je použita animace, je k dispozici volba ji vypnout a to dříve, než se poprvé použije.

### Kontrolní seznam pro zaměřování klávesnicí

ZK | Zaměření klávesnicí | Prošlo/Selhalo/Nepoužíváno
ZK.1 | Po otevření okna je zaměřen nejčastěji používaný ovládací prvek.
ZK.2 | Aktuální pozice v zaměření vstupu je vždy jasně zobrazena.
ZK.3 | Zaměření vstupu je zobrazené vždy jen v právě jednom okně.
ZK.4 | Když se uživatel pokusí dostat za konec skupiny souvisejících objektů, dostane vhodnou zvukovou nebo vizuální zpětnou odezvu.
ZK.5 | Když uživatel zmáčkne nesprávnou klávesu je přehráno výchozí zvukové a vizuální varování.
ZK.6 | Existuje dostatek zvukových informací pro vizuální zaměření, aby uživatel mohl posoudit, co má dělat dál.
ZK.7 | Když používáte asistenční technologie, jako je čtečka obrazovky nebo braillský řádek, aktuální program podává informaci o pozici a obsahu vizálního zaměření.

### Kontrolní seznam pro načasování

NČ | Načasování | Prošlo/Selhalo/Nepoužíváno
NČ.1 | A aplikaci se nepoužívají žádné napevno zakódované časové limity a funkce závisející na čase.
NČ.2 | Zobrazení nebo skrytí důležitých informací není spouštěno pouze pohybem ukazatele myši.

### Kontrolní seznam pro dokumentaci

DK | Dokumentace | Prošlo/Selhalo/Nepoužíváno
DK.1 | Veškerá dokumentace je v přístupném formátu, s alternativním textovým popisem pro všechny obrázky a schémata.
DK.2 | Součástí dokumentace je kapitola popisující všechny funkce zpřístupnění v aplikaci.

### GOK (GNOME Onscreen Keyboard)

Informace na této stránce jsou částečně neaktuální: Caribou v GNOME 3 v podstatě nahradil gok z GNOME 2.

Vaše aplikace by měla jít používat pomocí gok. Klávesové vstupy by měly být generovány zcela z gok a ne z klávesnice. Cílem by měla být práce s vaší aplikací a pracovním prostředím z obecného hlediska, ujistěte se, že z klávesnice na obrazovce je možné zadávat znaky.

Aplikace gok je šířena spolu s pracovním prostředím GNOME, takže v by něm měla být obsažena. Úplnou dokumentaci najdete na oficiálních webu gok.

Následující kroky ověří správnost operací gok s vaší aplikací:

1. Přihlaste se do pracovního prostředí GNOME.

2. Spusťte gok.

3. Spusťte aplikaci.

4. Proveďte nějaký vstup do své aplikace pomocí ukazovacího zařízení (např. myší nebo zařízením pro sledování očí) a pomocí gok.

5. Pracujte pomocí funkce automatického doplňování a odhadu slov v gok.

6. Ověřte, že gok zapíná a vypíná tlačítka Nabídky a Nástrojové lišty podle druhu spuštěné aplikace. Například pro aplet „Vlastnosti písma“ budou tato tlačítka vypnutá, zatímco pro aplikaci Gedit budou zapnutá.

7. Ověřte, že klávesnice na obrazovce gok lze za pomocí tlačítka Compose použít k psaní libovolného textu pro vybranou aplikaci. Spusťte Gedit, klikněte do textové oblasti a pak klikněte na tlačítko Compose v gok. Na klávesnici na obrazovce vyberte požadovanou klávesu. V textové oblasti aplikace Gedit by se měl objevit kýžený znak.

8. Ověřte, že spouštěcí tlačítko umožňuje spustit některou z aplikací terminál, webový prohlížeč nebo textový editor.

9. Ověřte, že tlačítko Aktivovat umožňuje uživateli aktivovat libovolné okno právě běžících aplikací v uživatelově pracovním prostředí, včetně panelů GNOME a plochy GNOME.

10. Ověřte, že tlačítko Nabídky ukáže všechny dostupné nabídky v právě běžící aplikaci. Ověřte, že kliknutí na tlačítko nabídky zobrazí podnabídku a položky v podnabídce. Nakonec ověřte, že kliknutím na položku nabídky se aktivuje položka nabídky. Například klikněte na aplikaci Prohlížeč nápovědy a pak klikněte na tlačítko Nabídky. Okno GOK nyní zobrazuje tlačítka Soubor, Přejít a Nápověda (nabídky aplikace Prohlížeč nápovědy). Klikněte na tlačítko Soubor a měla by se zobrazit tlačítka (položky nabídky) Nové okno a Zavřít okno.

11. Ověřte, že tlačítko Nástrojové lišty ukáže všechna dostupná tlačítka z nástrojové lišty aplikace. Například klikněte na aplikaci Prohlížeč nápovědy a pak klikněte na tlačítko Nástrojové lišty. Okno GOK by nyní mělo zobrazovat tlačítka Zpět, Vpřed a Domů.

12. Ověřte, že tlačítko Zachytit UR zobrazí všechna tlačítka pro vybrané okno aplikace. Například otevřete aplet „Vlastnosti písma“ a klikněte na tlačítko Zachytit UR v okně GOK. Okno GOK by nyní mělo zobrazovat názvy tlačítek v apletu – Patkové, Bezpatkové, Zavřít a Nápověda.

### Accerciser

Accerciser a architektura zpřístupnění v GNOME

Accerciser je interaktivní průzkumník zpřístupnění pro pracovní prostředí GNOME napsaný v jazyce Python. Používá AT-SPI ke zkoumání a ovládání widgetů, takže můžete zkontrolovat, jestli aplikace poskytuje správné informace asistenčním technologiím a automatizovaným testovacím systémům. Accerciser má jednoduchý základní rámec pro zásuvné moduly, který můžete použít k vytvoření vlastních zobrazení informací o zpřístupnění. Ucelenou dokumentaci najdete v oficiální příručce k aplikaci Accerciser. Na ukázku použití aplikace Accerciser a PyATSPI (Python-wrappered access and usage of AT-SPI) se podívejte do tohoto článku. Skvělou procházku zpřístupněním aplikace přímo od autorů najdete v článku s názvem Make Your Application Accessible with Accerciser.

Accerciser v podstatě nahradil starší nástroj at-poke.