<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY gnomeversion "2.24">
<!ENTITY manrevision "2.24.0">
<!ENTITY date "September 2008">
<!ENTITY LEGAL SYSTEM "legal.xml">
<!ENTITY gad SYSTEM "gad.xml">
<!ENTITY gtest SYSTEM "gtest.xml">
]>
<?db.chunk.max_depth 4?>
<book id="index" lang="de">
<title>GNOME Barrierefreiheitshandbuch für Entwickler</title>
<bookinfo>
<abstract role="description">
<para>Das GNOME Barrierefreiheitshandbuch ist für Entwickler bestimmt, die sicherstellen wollen, dass ihre Bemühungen dem größtmöglichen Anwenderkreis zu Gute kommen. Dieses Handbuch deckt auch die Erfordernisse des US-Rehabilitationsgesetzes 508 ab.</para>
</abstract>
<copyright><year>2008</year> <holder>Vincent Alexander</holder></copyright>
<copyright><year>2001, 2002</year> <holder>Calum Benson, Brian Cameron, Bill Haneman, Padraig O'Briain, Sharon Snider</holder></copyright>
<publisher role="maintainer"> 
<publishername>GNOME-Dokumentationsprojekt</publishername> 
</publisher>
<legalnotice id="legalnotice">
<para>Das vorliegende Dokument kann gemäß den Bedingungen der GNU Free Documentation License (GFDL), Version 1.1 oder jeder späteren, von der Free Software Foundation veröffentlichten Version ohne unveränderbare Abschnitte sowie ohne Texte auf dem vorderen und hinteren Buchdeckel kopiert, verteilt und/oder modifiziert werden. Eine Kopie der GFDL finden Sie unter diesem <ulink type="help" url="ghelp:fdl">Link</ulink> oder in der mit diesem Handbuch gelieferten Datei COPYING-DOCS.</para>
<para>Das vorliegende Handbuch ist Teil einer Reihe von GNOME-Handbüchern, die unter der GFDL verteilt werden. Wenn Sie dieses Handbuch separat verteilen möchten, können Sie dies tun, indem Sie dem Handbuch eine Kopie der Lizenz, wie in Abschnitt 6 der Lizenz beschrieben, hinzufügen.</para>
<para>Bei vielen der von Firmen zur Unterscheidung ihrer Produkte und Dienstleistungen verwendeten Namen handelt es sich um Marken. An den Stellen, an denen derartige Namen in einer GNOME-Dokumentation vorkommen und wenn die Mitglieder des GNOME-Dokumentationsprojekts über diese Marken informiert wurden, sind die Namen in Großbuchstaben oder mit großen Anfangsbuchstaben geschrieben.</para>
<para>DAS DOKUMENT UND MODIFIZIERTE VERSIONEN DES DOKUMENTS WERDEN GEMÄSS DEN BEDINGUNGEN DER GNU FREE DOCUMENTATION LICENSE MIT DER FOLGENDEN VEREINBARUNG BEREITGESTELLT: <orderedlist>
<listitem>
<para>DAS DOKUMENT WIRD »WIE VORLIEGEND« GELIEFERT, OHNE JEGLICHE GEWÄHRLEISTUNG, WEDER AUSDRÜCKLICH NOCH STILLSCHWEIGEND, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF, GEWÄHRLEISTUNGEN, DASS DAS DOKUMENT ODER EINE MODIFIZIERTE VERSION DES DOKUMENTS FREI VON HANDELSÜBLICHEN FEHLERN UND FÜR EINEN BESTIMMTEN ZWECK GEEIGNET IST UND KEINE RECHTE DRITTER VERLETZT. JEGLICHES RISIKO IN BEZUG AUF DIE QUALITÄT, GENAUIGKEIT UND LEISTUNG DES DOKUMENTS ODER EINER MODIFIZIERTEN VERSION DES DOKUMENTS TRAGEN SIE. SOLLTE SICH EIN DOKUMENT ODER EINE MODIFIZIERTE VERSION DAVON IN IRGENDEINER WEISE ALS FEHLERHAFT ERWEISEN, TRAGEN SIE (NICHT DER URSPRÜNGLICHE VERFASSER, AUTOR ODER EIN MITWIRKENDER) DIE KOSTEN FÜR JEGLICHE ERFORDERLICHE SERVICE-, REPARATUR- UND KORREKTURMASSNAHMEN: DIESE BESCHRÄNKUNG DER GEWÄHRLEISTUNG IST WESENTLICHER BESTANDTEIL DIESER LIZENZ. JEDE VERWENDUNG EINES DOKUMENTS ODER EINER MODIFIZIERTEN VERSION DES DOKUMENTS UNTERLIEGT DIESER BESCHRÄNKUNG; UND</para>
</listitem>
<listitem>
<para>UNTER KEINEN UMSTÄNDEN UND GEMÄSS KEINER RECHTSLEHRE, WEDER AUFGRUND VON UNERLAUBTEN HANDLUNGEN (EINSCHLIESSLICH FAHRLÄSSIGKEIT), VERTRÄGEN ODER SONSTIGEM, KANN DER AUTOR, DER URSPRÜNGLICHE VERFASSER, EIN MITWIRKENDER ODER EIN VERTEILER DES DOKUMENTS ODER EINER MODIFIZIERTEN VERSION DES DOKUMENTS ODER EIN LIEFERANT EINER DIESER PARTEIEN VON EINER PERSON FÜR DIREKTE, INDIREKTE, BESONDERE, ZUFÄLLIGE ODER ALS FOLGE AUFGETRETENE SCHÄDEN IRGENDEINER ART, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF, SCHÄDEN DURCH GESCHÄFTSWERTVERLUSTE, ARBEITSAUSFÄLLE, COMPUTERAUSFÄLLE ODER FUNKTIONSSTÖRUNGEN ODER JEGLICHE ANDERE SCHÄDEN ODER VERLUSTE, DIE DURCH ODER IM ZUSAMMENHANG MIT DER VERWENDUNG DES DOKUMENTS ODER EINER MODIFIZIERTEN VERSION DES DOKUMENTS ENTSTANDEN SIND, SELBST WENN DIESE PARTEI ÜBER MÖGLICHE SCHÄDEN INFORMIERT WORDEN SEIN SOLLTE, HAFTBAR GEMACHT WERDEN.</para>
</listitem>
</orderedlist></para>
</legalnotice>
 
<authorgroup> 
<author><firstname>Vincent</firstname> <surname>Alexander</surname> <affiliation> <orgname>GNOME Dokumentationsprojekt</orgname> </affiliation></author>
<author><firstname>Calum</firstname> <surname>Benson</surname> <affiliation> <orgname>GNOME Dokumentationsprojekt</orgname> </affiliation></author>
<author><firstname>Brian</firstname> <surname>Cameron</surname> <affiliation> <orgname>GNOME Dokumentationsprojekt</orgname> </affiliation></author>
<author><firstname>Bill</firstname> <surname>Haneman</surname> <affiliation> <orgname>GNOME Dokumentationsprojekt</orgname> </affiliation></author>
<author><firstname>Padraig</firstname> <surname>O'Briain</surname> <affiliation> <orgname>GNOME Dokumentationsprojekt</orgname> </affiliation></author> 
<author><firstname>Sharon</firstname> <surname>Snider</surname> <affiliation> <orgname>GNOME Dokumentationsprojekt</orgname> </affiliation></author>
</authorgroup>
<revhistory>
<revision><revnumber> GNOME 2.24 Barrierefreiheitshandbuch für Entwickler V2.24.0 </revnumber> <date>September 2008</date> <revdescription> 
<para role="author">GNOME-Dokumentationsprojekt</para> 
<para role="publisher">GNOME-Dokumentationsprojekt</para> 
</revdescription></revision>
<revision><revnumber> GNOME 2.24 Barrierefreiheitshandbuch für Entwickler V2.24.0 </revnumber> <date>September 2008</date> <revdescription> 
<para role="author">GNOME-Dokumentationsprojekt</para> 
<para role="publisher">GNOME-Dokumentationsprojekt</para> 
</revdescription></revision>
</revhistory>
<releaseinfo>Dieses Handbuch beschreibt Version 2.24 der GNOME-Arbeitsumgebung.</releaseinfo>
<legalnotice> 
<title>Rückmeldungen</title> 
<para>Wenn Sie Fehler finden oder Vorschläge zur GNOME-Arbeitsumgebung oder diesem Handbuch haben, folgen Sie den Anweisungen auf der <ulink type="help" url="ghelp:user-guide?feedback">GNOME-Seite für Rückmeldungen</ulink>.</para>
</legalnotice> 

    <othercredit class="translator">
      <personname>
        <firstname>Mario Blättermann</firstname>
      </personname>
      <email>mario.blaettermann@gmail.com</email>
    </othercredit>
    <copyright>
      
        <year>2009</year>
      
        <year>2016</year>
      
        <year>2021</year>
      
      <holder>Mario Blättermann</holder>
    </copyright>
  
    <othercredit class="translator">
      <personname>
        <firstname>Christian Kirbach</firstname>
      </personname>
      <email>christian.kirbach@gmail.com</email>
    </othercredit>
    <copyright>
      
        <year>2014</year>
      
      <holder>Christian Kirbach</holder>
    </copyright>
  
    <othercredit class="translator">
      <personname>
        <firstname>Tim Sabsch</firstname>
      </personname>
      <email>tim@sabsch.com</email>
    </othercredit>
    <copyright>
      
        <year>2021</year>
      
      <holder>Tim Sabsch</holder>
    </copyright>
  </bookinfo>
<chapter id="gad" status="draft">
<title>Was ist Barrierefreiheit?</title>
<para>Barrierefreiheit bedeutet, Menschen mit Behinderungen zu helfen, an grundlegenden Lebensaktivitäten teilzunehmen. Das beinhaltet einer Arbeit nachzugehen und Dienste, Produkte und Informationen zu nutzen. GNOME enthält Bibliotheken und ein Framework, das es Menschen mit Behinderungen ermöglicht, alle Funktionen der GNOME-Benutzerumgebung zu verwenden.</para>
<para>Im Zusammenspiel mit gegebenenfalls notwendigen Hilfstechnologien wie Sprachausgaben, Bildschirmlesern oder alternativen Eingabegeräten wird Menschen mit vorübergehenden oder dauerhaften Behinderungen die Nutzung der GNOME-Arbeitsumgebung und deren Anwendungen ermöglicht. Hilfstechnologien können auch sinnvoll sein, wenn Rechner außerhalb von Zuhause oder Büro genutzt werden. Wenn Sie beispielsweise im Stau stehen, werden Sie vielleicht die Spracheingabe und -ausgabe für E-Mail-Nachrichten bevorzugen.</para>
<para>Hilfstechnologien empfangen Informationen von Anwendungen über die Schnittstelle des »Accessibility Toolkit (ATK)«, welches Sie im Modul »atk« des GNOME-Softwarebestandes finden. Da die Unterstützung für die Barrierefreiheits-Schnittstelle bereits in die GNOME-Widgets eingebaut ist, sollte Ihr GNOME-Programm Hilfstechnologien bereits grundlegend unterstützen, ohne dass Mehraufwand Ihrerseits notwendig wäre. Beispielsweise können Hilfstechnologien automatisch die Beschriftungen lesen, die Sie ohnehin in der Benutzeroberfläche festlegen (mit Hilfe von GTK-Funktionsaufrufen wie <function>gtk_label_set_text()</function> oder <function>gtk_button_new_with_label()</function>). Sie finden auch heraus, ob eine Beschriftung mit einer Minihilfe gekoppelt ist, und verwenden diese für die Beschreibung des Widgets für den Benutzer.</para>
<para>Mit geringem Mehraufwand können Sie Ihr Programm besser auf die Zusammenarbeit mit Hilfstechnologien trimmen. Sie helfen in erster Linie bestimmten Benutzergruppen, machen Ihr Programm aber auch attraktiver für Endanwender im Verwaltungs- und Bildungssektor, wo barrierefreie Anwendungen oft gesetzlich vorgeschrieben sind.</para>

<section>
<title>Arten von Behinderungen</title>
<para>Allein in den USA leben schätzungsweise 30 Millionen Menschen, deren Fähigkeit zur Benutzung von Rechnern durch nicht barrierefreies Design eingeschränkt ist. Weltweit haben etwa 8% der Nutzer des World Wide Web irgendeine Art von Behinderung. Solche Behinderungen fallen in eine dieser Kategorien:</para>
<itemizedlist>
<listitem>
<para><emphasis>Seheinschränkungen</emphasis> - sie reichen von Sehschwäche (dazu gehört unter anderem trübe oder verschwommene Sicht, starke Weit- oder Kurzsichtigkeit, Farbenblindheit und Tunnelblick) bis hin zu totaler Blindheit. Eine schlechte Wahl der Textgröße und -farbe sowie Aufgaben, die eine gute Hand-Auge-Koordination benötigen (z.B. das Bewegen der Maus) können Probleme für diese Benutzer verursachen.</para>
</listitem>
<listitem>
<para><emphasis>Bewegungseinschränkungen</emphasis> - Benutzer mit geringer Muskelkontrolle oder Muskelschwäche können Probleme haben, eine Standardtastatur und -maus zu verwenden. Es mag ihnen zum Beispiel nicht möglich sein, zwei Tasten gleichzeitig gedrückt zu halten, oder sie treffen Tasten versehentlich.</para>
</listitem>
<listitem>
<para><emphasis>Hörschädigungen</emphasis> - Diese reichen von der Fähigkeit, einige Geräusche wahrzunehmen, jedoch gesprochene Worte nicht erkennen zu können, bis hin zu vollständiger Gehörlosigkeit. Anwendungen, die wichtige Informationen nur über Geräusche vermitteln, stellen ein Problem für diese Benutzer dar.</para>
</listitem>
<listitem>
<para><emphasis>Geistige und sprachliche Einschränkungen</emphasis> - Diese reichen von Lernhürden bis zu Gedächtnisschwächen, Schwierigkeiten Probleme zu lösen und gesprochene und geschriebene Sprache zu verwenden. Komplizierte oder widersprüchliche Anzeigen sowie eine schwache Wortwahl erschweren diesen Benutzern den Zugang zum Computer.</para>
</listitem>
<listitem>
<para><emphasis>Anfälle</emphasis> - Bestimmte Licht- oder Geräuschereignisse können einen epileptischen Anfall bei einigen anfälligen Benutzern hervorrufen.</para>
</listitem>
</itemizedlist>
</section>

<section id="gad-how-it-works">
<title>Wie funktioniert Barrierefreiheit in GNOME?</title>
<para>Das Accessibility Toolkit (ATK) beschreibt eine Sammlung von Interfaces, die von GUI-Komponenten implementiert werden müssen, um sie barrierefrei zu gestalten. Die Interfaces sind unabhängig vom Toolkit - Implementierungen können für beliebige Widgets geschrieben sein, u.a. GTK, Motif und Qt.</para>
<para>Die Implementierung der GTK-Widgets wird von der Klasse GTKAccessible übernommen. Dabei handelt es sich um einen dünnen Wrapper um AtkObjekt, welches Möglichkeiten zum Assoziieren eines Widgets mit seinem barrierefreien Objekt hinzufügt. Die Teile Ihrer Anwendung, die Standard-GTK-Widgets verwenden, haben bereits ein gewisses Maß an Barrierefreiheit, ohne dass sie selbst Hand anlegen müssen.</para>
<para>Die meisten Hilfstechnologien (AT), die auf anderen Arbeitsumgebungen laufen, fanden es wichtig, ein kompliziertes, vom Bildschirm losgelöstes Modell für Arbeitsflächenanwendungen zu unterhalten, das auf dem Auslesen von Betriebssystem-Ereignissen aufbaute, sowie nicht unterstützte Betriebssystem- und Anwendungseigenschaften und APIs, und andere kaum portierbare Techniken. Dies führte zu einer »spröden« und höchst betriebssystem- und anwendungsspezifischen, manchmal sogar versionsspezifischen Unterstützung von Hilfstechnologien. Im Gegensatz dazu steht die GNOME-Arbeitsumgebung, auf der alle von Hilfstechnologien benötigten Informationen von den laufenden Anwendungen bereitgestellt werden. Diese laufen über das GNOME Barrierefreiheits-Framework zu einem Toolkit-unabhängigen »Service Provider Interface« (SPI, etwa »Dienstleistungs-Anbieter-Schnittstelle«). Das SPI bietet Mittel für UNIX-basierte Hilfstechnologien, wie zum Beispiel Bildschirmleser und Bildschirmlupen, um Barrierefreiheitsinformationen für laufende Anwendungen über eine konsistente und stabile API zu erhalten und kann den Bedarf an vom Bildschirm losgelöste Modelle in vielen Fällen beseitigen. Unterstützung für Barrierefreiheit für Anwendungen ist in Anwendungstoolkits über Toolkit-entprechende APIs »eingebaut« (z.B. ATK für die meisten nativen C-Anwendungen und die Java Accessibility API für Java Apps), und wird über die betreffenden »Brücken« in die allgemeine »AT-SPI«-Schnittstelle exportiert (siehe Diagramm).</para>
<!--
<figure id="gad-architecture">
<title>GNOME Accessibility Architecture</title>
<mediaobject>
<imageobject>
<imagedata fileref="figures/GNOME_desktop_Accessibility.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Diagram of GNOME's accessibility architecture</phrase>
</textobject>
</mediaobject>
</figure>
-->
<para>Die in GNOME enthaltene Unterstützung für Barrierefreiheit drückt sich darin aus, dass Sie bei der Verwendung von Standard-GNOME-Widgets die Unterstützung für Hilfstechnologien praktisch »umsonst« erhalten, sofern die Widgets nicht auf unübliche Weise verwendet werden, was zu Konflikten in der eingebauten Unterstützung führen kann.</para>
<para>Ein GTK/GNOME-Widget ist barrierefrei, wenn dessen Benutzung den allgemeinen Richtlinien zur Barrierefreiheit in diesem Dokument folgt, und es die ATK-Interfaces umsetzt, die zur Rolle in der Benutzeroberfläche gehören. ATK-Umsetzungen werden für die Standard-GNOME-Toolkit-Widgets (d.h. nicht veraltete GTK- und GNOME-Widgets) bereit gestellt, und in vielen Fällen erben neue Widgets passende Unterstützung für Barrierefreiheit, welche sich trivial von existierenden GTK- oder GNOME-Widgets ableiten.</para>
<para>Die in GNOME eingebaute Unterstützung für Hilfstechnologien bietet bereits einen beträchtlichen Funktionsumfang, ohne dass Anwendungscode hinsichtlich Barrierefreiheit angepasst werden muss. Dennoch können Anwendungen häufig davon profitieren, wenn die bereitgestellten Standardbeschreibungen für einige Widgets verbessert und auf den spezifischen Zweck in der Anwendung zugeschnitten werden, indem ATK-Methoden direkt innerhalb der Anwendung aufgerufen werden. Beispielsweise können Textbeschreibungen für diese Widgets mit dem geeigneten ATK-Funktionsaufruf hinzugefügt oder geändert werden, so dass Hilfstechnologien dem Nutzer deren Zweck oder Status beschreiben können. Lesen Sie dazu auch <link linkend="gad-coding-guidelines">Programmierrichtlinien zur Unterstützung von Barrierefreiheit</link> für weitere Informationen.</para>
<para>Wenn Ihr Programm benutzerdefinierte Widgets verwendet, müssen Sie eventuell ein wenig Arbeit leisten, um diese Widget-Eigenschaften Hilfstechnologien zugänglich zu machen. Lesen Sie auch <link linkend="gad-custom">Eigene Komponenten barrierefrei machen</link> und <link linkend="gad-api-examples">Beispiele, welche die Barrierefreiheit-API verwenden</link> für weitere Informationen.</para>
<para>Zusätzliche, weiterführende Informationen zu GTK finden Sie im <ulink url="https://developer.gnome.org/gtk3/">GTK-Referenzhandbuch</ulink>, dem veralteten, bei GNOME gehosteten <ulink url="https://developer.gnome.org/gtk-tutorial/stable/">GTK-2.0-Tutorial</ulink> und den offiziellen <ulink url="https://developer.gnome.org/gtk3/stable/gtk-question-index.html">GTK-FAQ</ulink>.</para>
</section>

<section id="dev-start">
<title>Schnelleinstieg für Entwickler</title>
<para>Hier einige übliche Einstiegspunkte:</para>

<section id="dev-start-1">
<title>Wie kann ich überprüfen, ob meine Anwendung barrierefrei ist oder nicht?</title>
<para>Um direkt reinzuspringen, lesen Sie <link linkend="gad-overview">Eine GNOME-Anwendung barrierefrei gestalten - Überblick</link>. Für eine generellere Betrachtung vor dem Programmieren, lesen Sie <link linkend="gad-ui-guidelines">Richtlinien für Benutzeroberflächen zur Unterstützung der Barrierefreiheit</link> oder <link linkend="gad-coding-guidelines">Code-Richtlinien zur Unterstützung der Barrierefreiheit</link>. Eine Checkliste zum Testen Ihrer Anwendung finden Sie unter <link linkend="gad-checklist">Checkliste für Benutzeroberflächen</link>.</para>
</section>

<section id="dev-start-2">
<title>Wo lauern die häufigsten Fallen?</title>
<para>Die <link linkend="gad-checklist">Checkliste für Benutzeroberflächen</link> deckt alle Bereiche ab, die manchmal in der Planungsphase übersehen werden.</para>
</section>

<section id="dev-start-3">
<title>Wie führe ich allgemeine ATK-Angelegenheiten aus?</title>
<para>Eine gekürzte Liste häufiger ATK-Aufrufe finden Sie <link linkend="gad-api">hier</link>.</para>
</section>

<section id="dev-start-4">
<title>Wie führe ich komplexere ATK-Angelegenheiten aus?</title>
<para>Siehe <link linkend="gad-custom">Benutzerdefinierte Komponenten barrierefrei gestalten</link> und <link linkend="gad-api-examples">Beispiele für die Nutzung der Barrierefreiheits-API</link> für weitere Informationen.</para>
</section>

<section id="dev-start-5">
<title>Einführung in ATK, AT-SPI, und GTK</title>
<screenshot>
<mediaobject><imageobject> <imagedata fileref="figures/gaa.jpg"/> </imageobject> <textobject> <phrase> Architektur der Zugangshilfen von GNOME </phrase> </textobject></mediaobject>
</screenshot>
<para>ATK ist das Toolkit, welches GNOME einsetzt, um Barrierefreiheit für Benutzer zu schaffen, welche eine Zusatzunterstützung brauchen, um ihre Rechner vollständig nutzen zu können. ATK wird von Werkzeugen wie Bildschirmleser, Lupen und Eingabegeräte verwendet, um eine gute Interaktion mit der Arbeitsumgebung mittels alternativer Wege zu schaffen. Lesen Sie auch <ulink url="http://java-gnome.sourceforge.net/doc/api/4.1/org/gnome/atk/package-summary.html">das ATK-SourceForge-Projekt</ulink> und <ulink url="https://developer.gnome.org/atk/stable/">die ATK-Bibliothek</ulink> für weitere Informationen.</para>
<para>AT-SPI ist das primäre Service-Interface für Hilfstechnologien, um Informationen von laufenden Anwendungen anzufragen und zu empfangen. Die vollständige API ist <ulink url="https://developer.gnome.org/at-spi-cspi/stable/">hier</ulink> dokumentiert.</para>
<para>GTK ist eine Bibliothek zum Erstellen grafischer Benutzeroberflächen. Sie funktioniert auf vielen UNIX-ähnlichen Plattformen, unter Windows und mit Framebuffer-Geräten. GTK wird unter der GNU Library General Public License (GNU LGPL) veröffentlicht, die eine flexible Lizenzierung der Client-Anwendungen erlaubt. GTK verfügt über eine C-basierte objektorientierte Architektur, die ein Maximum an Flexibilität ermöglicht. Es wurden Bindings für andere Sprachen geschrieben, beispielsweise C++, Objective-C, Guile/Scheme, Perl, Python, TOM, Ada95, Free Pascal und Eiffel. Seine GtkAccessible-Klasse ist die Basisklasse für barrierefreie Implementierungen von GtkWidget-Subklassen. Es ist ein dünner Wrapper um AtkObjekt, welches Möglichkeiten zum Assoziieren eines Widgets mit seinem barrierefreien Objekt hinzufügt.</para>
<para>Zusätzliche, weiterführende Informationen zu GTK finden Sie im <ulink url="https://developer.gnome.org/gtk3/">GTK-Referenzhandbuch</ulink>, <ulink url="https://wiki.gnome.org/Accessibility/Documentation/GNOME2/AtkGuide/Gtk">dem GTK-Abschnitt der ATK-Richtlinien</ulink>, dem veralteten, bei GNOME gehosteten <ulink url="https://developer.gnome.org/gtk-tutorial/stable/">GTK-2.0-Tutorial</ulink> und den offiziellen <ulink url="https://developer.gnome.org/gtk3/stable/gtk-question-index.html">GTK-FAQ</ulink>.</para>
</section>
</section>

<section id="gad-overview">
<title>Eine GNOME-Anwendung barrierefrei gestalten - Überblick</title>
<para>Wenn Ihr Programm nur Standard-GTK-Widgets nutzt, werden Sie vermutlich wenig bis gar nichts tun müssen, um Ihr Programm (einigermaßen) barrierefrei zu gestalten. Sie sollten aber nach Objekten in Ihrer GUI schauen, welche keine Text-Beschreibung haben, welche mit ihnen verknüpft ist, wie z.B. grafische Knöpfe oder Statusanzeigen, die keine Aufschriften oder Mini-Hilfen haben.</para>
<para>Sie könnten vielleicht auch die bereitgestellten Standardbeschreibungen für einige Widgets verbessern, und sie auf den Widget-spezifischen Zweck Ihres Programms zuschneiden. Sie sollten Textbeschreibungen für diese Widgets mit dem geeigneten ATK-Funktionsaufruf hinzufügen oder ändern, so dass Hilfstechnologien dem Nutzer deren Zweck oder Status beschreiben können. Lesen Sie dazu auch <link linkend="gad-coding-guidelines">Programmierrichtlinien zur Unterstützung von Barrierefreiheit</link> für weitere Informationen.</para>
<para>Wenn Ihr Programm benutzerdefinierte Widgets verwendet, müssen Sie eventuell ein wenig Arbeit leisten, um diese Widget-Eigenschaften Hilfstechnologien zugänglich zu machen. Lesen Sie auch <link linkend="gad-custom">Eigene Komponenten barrierefrei machen</link> und <link linkend="gad-api-examples">Beispiele, welche die Barrierefreiheit-API verwenden</link> für weitere Informationen.</para>
</section>

<section id="gad-coding-guidelines">
<title>Code-Richtlinien zur Unterstützung der Barrierefreiheit</title>
<para>Hier finden Sie einige Dinge, die Sie in Ihren Code einbauen können, damit Ihr Programm so gut wie irgend möglich mit Hilfstechnologien funktioniert (Sie finden eine Liste der beim Entwurf Ihrer Benutzeroberfläche zu beachtenden Dinge im Abschnitt <link linkend="gad-ui-guidelines">Richtlinien für Benutzeroberflächen zur Unterstützung der Barrierefreiheit</link> weiter unten in diesem Dokument):</para>
<itemizedlist>
<listitem>
<para>Geben Sie Komponenten, die keine kurze Zeichenkette anzeigen (wie ein grafischer Knopf), mit <function>atk_object_set_name()</function> einen Namen. Sie können das für Knöpfe mit einem Bild, Panels mit logischen Gruppierungen, Textbereiche usw. tun.</para>
</listitem>
<listitem>
<para>Falls Sie keine Minihilfe für eine Komponente verwenden können, verwenden Sie stattdessen <function>atk_object_set_description()</function>, um eine Beschreibung bereitzustellen, die eine Hilfstechnologie an den Benutzer weitergeben kann. Eine barrierefreie Beschreibung für einen <guibutton>Close</guibutton>-Knopf stellen Sie beispielsweise folgendermaßen bereit:</para>
<example>
<title>Bereitstellung einer barrierefreien Beschreibung für einen GtkButton</title>
<programlisting>
{
  AtkObject *obj;
  obj = gtk_widget_get_accessible(button);
  atk_object_set_description(obj,_("Closes the window"));
}
</programlisting>
</example>
</listitem>
<listitem>
<para>Verwenden Sie <function>atk_image_set_description()</function>, um eine Beschreibung in Textform für alle Bilder und Symbole in Ihrem Programm bereitzustellen.</para>
</listitem>
<listitem>
<para>Falls verschiedene Komponenten eine logische Gruppe bilden, versuchen Sie, diese in einem Container unterzubringen.</para>
</listitem>
<listitem>
<para>Wenn Sie eine Beschriftung (ein Label) haben, die eine andere Komponente beschreibt, verwenden Sie <function>atk_relation_set_add_relation()</function>, damit Hilfstechnologien erkennen, auf welche Komponente sich die Beschriftung bezieht. (Alternativ können Sie die Beschriftung auch über <function>gtk_label_set_mnemonic_widget()</function> mit einer Komponente verknüpfen. Dadurch wird die Beziehung <constant>ATK_RELATION_LABEL_FOR</constant> automatisch generiert, sodass der folgende Code nicht notwendig wäre):</para>
<example>
<title>Beziehen eines GtkLabel auf ein GtkWidget</title>
<programlisting>
{
  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));
}
</programlisting>
</example>
</listitem>
<listitem>
<para>Falls Sie ein benutzerdefiniertes Widget erstellen, sollten Sie sicherstellen, dass es barrierefrei ist. Benutzerdefinierte Komponenten, die von anderen GTK-Widgets abstammen, erben die notwendigen Barrierefreiheits-Informationen. Weitere Informationen hierzu finden Sie in <link linkend="gad-custom">Benutzerdefinierte Komponenten barrierefrei gestalten</link>.</para>
</listitem>
<listitem>
<para>Machen Sie nicht kaputt, was Sie umsonst bekommen! Wenn Ihre Benutzeroberfläche einen nicht-barrierefreien Container beinhaltet, könnten auch die Komponenten im Container nicht-barrierefrei werden.</para>
</listitem>
</itemizedlist>
</section>

<section id="gad-api">
<title>Die Barrierefreiheits-API</title>
<para>Nachfolgend finden Sie einige grundlegende API-Aufrufe, die Sie in Ihrer Anwendung nutzen können, um das reibungslose Zusammenwirken mit Hilfstechnologien sicher zu stellen. Die gesamte Barrierefreiheits-API ist erweiterbar, so dass Sie beispielsweise Ihre eigenen benutzerdefinierten, barrierefreien Widgets erstellen können.</para>
<table frame="all">
<title>Häufig genutzte API-Aufrufe von ATK</title>
<tgroup cols="2" align="left">
<thead>
<row>
<entry>API</entry>
<entry>Beschreibung</entry>
</row>
</thead>
<tbody>
<row>
<entry>
<para><function>AtkObject* gtk_widget_get_accessible (GtkWidget*)</function></para>
</entry>
<entry>
<para>Gibt das barrierefreie Objekt zurück, welches das angegebene GTK-Widget für eine Hilfstechnologie beschreibt.</para>
</entry>
</row>
<row>
<entry>
<para><function>void atk_object_set_name (AtkObject*, const gchar*)</function></para>
</entry>
<entry>
<para>Legt den Namen des barrierefreien Objekts fest. Wenn beispielsweise das Objekt ein grafischer Knopf ist, der beim Anklicken die Anwendung beendet, könnte der Name »Quit« lauten.</para>
</entry>
</row>
<row>
<entry>
<para><function>void atk_object_set_description (AtkObject*, const gchar*)</function></para>
</entry>
<entry>
<para>Legt die Beschreibung in Textform für das barrierefreie Objekt fest. Wenn beispielsweise das Objekt ein grafischer »Close«-Knopf ist, dann könnte die Beschreibung »Closes the window« lauten.</para>
</entry>
</row>
<row>
<entry>
<para><function>AtkRelation* atk_relation_new (AtkObject**, gint, AtkRelationType)</function></para>
</entry>
<entry>
<para>Erstellt einen neuen Bezug zwischen dem angegebenen Schlüssel und der angegebenen Liste der Zielobjekte. Eine solche Beziehung informiert normalerweise die Hilfstechnologie darüber, dass ein Widget in einem bestimmten Verhältnis zu einem anderen steht. Beispielsweise ist ein bestimmtes GtkLabel eine Beschriftung für ein GtkTreeView im gleichen Fenster.</para>
</entry>
</row>
<row>
<entry>
<para><function>void atk_image_set_description (AtkImage*, const gchar*)</function></para>
</entry>
<entry>
<para>Legt die Beschreibung in Textform für das barrierefreie Bildobjekt fest. Wenn das Objekt beispielsweise ein Vorschaubild auf eine virtuelle Arbeitsfläche in einem Panel-Applet ist, dann könnte die Beschreibung »Image showing window arrangement on desktop 1« lauten.</para>
</entry>
</row>
</tbody>
</tgroup>
</table>
</section>

<section id="gad-api-examples">
<title>Beispiele für die Nutzung der Barrierefreiheits-API</title>
<para>Wie bereits erwähnt, sollte der Aufwand gering sein, wenn Sie Ihre Anwendung mit Hilfe der GTK-Widgetsammlung oder jeder anderen die ATK-Schnittstelle nutzenden Widgetsammlung barrierefrei gestalten. Dies sind die zwei häufigsten Aufgaben in diesem Fall:</para>
<itemizedlist>
<listitem>
<para>Bereitstellung von Beschreibungen von Bedienelementen mit <function>atk_object_set_description()</function> oder <function>atk_image_set_description():</function></para>
<example>
<title>Festlegen der barrierefreien Beschreibung für einen Knopf</title>
<programlisting>
{
   AtkObject *obj;
   obj = gtk_widget_get_accessible(button);
   atk_object_set_description(obj,_("Opens Preferences dialog"));
}
</programlisting>
</example>
<para>
</para>
</listitem>
<listitem>
<para>Angeben von Beziehungen zwischen unüblichen Widget-Gruppierungen mittels <function>atk_relation_new()</function> und <function>atk_relation_set_add()</function>:</para>
<example>
<title>Festlegen einer barrierefreien Beziehung zwischen zwei Bedienelementen</title>
<programlisting>
{
  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));
}
</programlisting>
</example>
</listitem>
</itemizedlist>
<para>Die übrigen Beispiele in diesem Abschnitt sollen Ihnen vornehmlich einen Eindruck verschaffen, was Sie mit ATK erreichen können. Es werden Techniken gezeigt, die Sie als Anwendungsentwickler vielleicht niemals einsetzen müssen, auch wenn sie gegebenenfalls interessant werden, wenn Sie Ihre eigenen benutzerdefinierten Widgets schreiben möchten (siehe <link linkend="gad-custom">Benutzerdefinierte Komponenten barrierefrei gestalten</link>), oder wenn Sie eine Hilfstechnologie-Anwendung schreiben möchten.</para>

<section>
<title>Barrierefreiheitsinformationen einer Anwendung sammeln</title>
<para>Ein Programm, das ATK-Aufrufe auswerten möchte, muss voraussichtlich eine (oder mehrere) der folgenden Dinge integrieren:</para>
<orderedlist>
<listitem>
<para>Erzeugen Sie einen EventListener, zum Beispiel über die Funktion <function>atk_add_focus_tracker()</function>:</para>
<programlisting>atk_add_focus_tracker (_my_focus_tracker);</programlisting>
<para>wobei <function>_my_focus_tracker()</function> eine Funktion folgenden Prototyps ist:</para>
<programlisting>void _my_focus_tracker (AtkObject *aobject);</programlisting>
</listitem>
<listitem>
<para>Erstellen Sie einen globalen EventListener mit »atk_add_global_event_listener()«:</para>
<programlisting>
mouse_watcher_focus_id = atk_add_global_event_listener(_my_global_listener, "Gtk:GtkWidget:enter_notify_event");
</programlisting>
<para>wobei <function>_my_global_listener</function> den Prototypen eines Glib <type>GSignalEmissionHook</type> besitzt. Bei diesem Beispiel würde <function>_my_global_listener()</function> jedes Mal aufgerufen werden, wenn es ein »enter_notify_even«-Signal auf einem <type>GtkWidget</type> gibt.</para>
</listitem>
<listitem>
<para>Greifen Sie mit folgendem Funktionsaufruf auf das Toplevel-ATK-Objekt zu:</para>
<programlisting>AtkObject *root_obj = atk_get_root();</programlisting>
<para>Dies gibt ein <type>AtkObject</type> zurück, das alle Toplevel-Fenster in dem aktuell laufenden Programm enthält. Der Benutzer kann anschließend durch die Objekt-Hierarchie navigieren, indem er auf die Kindelemente des Wurzelobjekts zugreift, die den Toplevel-Fenstern entsprechen.</para>
</listitem>
</orderedlist>
</section>

<section>
<title>Die Interfaces eines <type>AtkObject</type>s abfragen</title>
<para>Sobald Sie das <type>AtkObject</type> identifiziert haben, das mit einem Objekt in der Anwendung verknüpft ist (z.B. indem Sie <function>gtk_widget_get_accessible()</function> verwendet haben), können Sie auf verschiedene Wege herausfinden, welche Interfaces es implementiert:</para>
<orderedlist>
<listitem>
<para>Verwenden Sie die <function>ATK_IS_...</function> Makros, zum Beispiel:</para>
<itemizedlist>
<listitem>
<para><function>ATK_IS_ACTION(atkobj)</function></para>
</listitem>
<listitem>
<para><function>ATK_IS_COMPONENT(atkobj)</function></para>
</listitem>
<listitem>
<para>etc. (es gibt eins für jedes Interface)</para>
</listitem>
</itemizedlist>
<para>Wenn das Makro <function>TRUE</function> zurückgibt, können Sie sicher Interface-Aufrufe auf das ATK-Objekt durchführen.</para>
</listitem>
<listitem>
<para>Testen Sie die Rolle des <type>AtkObject</type>s, indem Sie <function>atk_object_get_role()</function> aufrufen. Jede Rolle implementiert eine Anzahl an ATK-APIs.</para>
</listitem>
</orderedlist>
</section>

<section>
<title>Einen ATK-Signalhandler einrichten</title>
<para>Als Beispiel verwenden wir das Signal <constant>column_inserted</constant>:</para>
<programlisting>
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);
</programlisting>
<para>Hier wird <function>_my_table_column_inserted_func()</function> jedes Mal aufgerufen, wenn das Signal »column_inserted« auf dem <type>AtkObject</type> <varname>my_atk_object</varname> ausgesandt wurde.</para>
<para>Sich mit einem Signal zu verbinden funktioniert etwas unterschiedlich, wenn das Signal Details unterstützt. Das Signal <constant>children_changed</constant> unterstützt das Detail <parameter>add</parameter>. Um sich mit einem Signal zu verbinden, wenn zusätzlich das <parameter>add</parameter> -Detail angegeben ist, können Sie folgende Technik verwenden:</para>
<programlisting>
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);
</programlisting>
<para>Dies führt dazu, dass <function>_my_children_changed_func()</function> jedes Mal aufgerufen wird, wenn das Signal <constant>children_changed</constant> mit dem <parameter>add</parameter>-Detail auf dem <type>AtkObject</type> <varname>my_atk_obj</varname> ausgesandt wird.</para>
</section>

<section>
<title>Implementieren eines ATK-Objekts</title>
<section>
<title>Registry</title>
<para>Für dieses Beispiel nehmen wir an, dass es ein Objekt namens GTK_TYPE_MYTYPE gibt. Die ATK-Implementierung wird <type>MYATKIMP_TYPE_MYTYPE</type> genannt. Es wird eine Factory benötigt, die <type>MYATKIMP_TYPE_MYTYPE_FACTORY</type> heißt.</para>
<para>Um eine ATK-Implementierung auf einem GTK-Objekt zu registrieren, müssen die folgenden Schritte in der Modulfunktion <function>gtk_module_init()</function> ausgeführt werden:</para>
<orderedlist>
<listitem>
<para>Greifen Sie auf die Standard-Registry zu:</para>
<programlisting>
default_registry = atk_get_default_registry();
</programlisting>
</listitem>
<listitem><para>Registrieren Sie das ATK-Objekt in der Funktion <function>gtk_module_init()</function> dieses Moduls über folgenden Funktionsaufruf:</para>
<programlisting>
atk_registry_set_factory_type (default_registry, GTK_TYPE_MYTYPE, 
MYATKIMP_TYPE_MYTYPE_FACTORY); 
</programlisting>
</listitem>
</orderedlist>
<para>Dies registriert die AtkObject-Implementierung von <type>GTK_TYPE_MYTYPE</type> in <type>MYATKIMP_TYPE_MYTYPE_FACTORY</type>. Die Factory wird so implementiert, dass sie in der Lage ist, Objekte vom Typ <type>MYATKIMP_TYPE_MYTYPE</type> zu erzeugen.</para>
</section>

<section>
<title>Factory</title>
<para>Die Factory muss als Kind des Klassentyps <type>ATK_TYPE_OBJECT_FACTORY</type> implementiert sein und die Funktion <function>create_accessible()</function> implementieren. Diese Funktion muss ein entsprechendes <type>AtkObject</type> erzeugen. Eine Factory kann zum Erzeugen mehrerer Objekttypen verwendet werden, wobei dessen <function>create_accessible()</function>-Funktion intelligent genug sein muss, das korrekte <type>AtkObject</type> zu erstellen und zurück zu liefern.</para>
</section>

<section>
<title>ATK-Implementierung für ein bestimmtes Objekt</title>
<para>Jedes <type>GObject</type> implementiert eine <function>get_type()</function>-Funktion. Im vorstehenden Beispiel wäre die Namenskonvention für diese Funktion <function>myatkimp_mytype_get_type()</function>.</para>
<para>In dieser Funktion geben Sie an, welche Interfaces Ihr Objekt implementiert. Falls die folgende Logik in der <function>get_type()</function>-Funktion eingeschlossen wäre, dann würde das folgende Objekt das Interface <type>ATK_TEXT</type> implementieren:</para>
<example>
<title>Beispiel für eine <function>get_type()</function>-Funktion</title>
<programlisting>
static const GInterfaceInfo atk_text_info = 
{ 
   (GInterfaceInitFunc) atk_text_interface_init, 
   (GInterfaceFinalizeFunc) NULL, 
   NULL 
}; 

g_type_add_interface_static (type, ATK_TYPE_TEXT, 
                             &amp;atk_text_info); 
</programlisting>
</example>
<para>Die Funktion <function>atk_text_interface_init()</function> mit dem folgenden Prototyp müsste implementiert werden:</para>
<programlisting>
void atk_text_interface_init (AtkTextIface *iface); 
</programlisting>
<para>Diese Funktion würde die Funktionsaufrufe des Interfaces zur spezifischen Implementierung wie folgt verbinden:</para>
<example>
<title>Benutzerdefinierte Interface-Aufrufe mit einer AtkObject-Implementierung verbinden</title>
<programlisting>
void 
atk_text_interface_init (AtkTextIface *iface) 
{ 
   g_return_if_fail (iface != NULL); 
   iface-&gt;get_text = myatkimp_mytype_get_text; 
   iface-&gt;get_character_at_offset = myatkimp_mytype_get_character_at_offset; 
   ... 
}
</programlisting>
</example>
<para>Dann müssen die Funktionen <function>myatkimp_mytype_get_text()</function>, <function>myatkimp_mytype_get_character_at_offset()</function> und der Rest der <type>ATK_TEXT</type>-Interfacefunktionen implementiert werden.</para>
</section>

<section>
<title><type>AtkObject</type>-Implementierung</title>
<para><type>AtkObject</type>e sind <type>GObject</type>e, und jedes <type>GObject</type> muss die Funktion <function>get_type()</function> spezifizieren. Im Folgenden wird ein Beispiel präsentiert, das einen Klassen- sowie Instanz-Initialisierer erstellt. Die Funktion <function>get_type()</function> spezifiziert ebenfalls, dass das Objekt <type>ATK_TEXT</type> implementiert, als auch, dass das Elternobjekt ein <type>MYATKIMP_MYPARENTTYPE</type> ist.</para>
<!--
<example>
<title>Sample <function>get_type()</function> implementation</title>
<programlisting>
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", &amp;tinfo, 0); 

      /* This class implements interface ATK_TYPE_TEXT */ 
      g_type_add_interface_static (type, ATK_TYPE_TEXT, 
                                   &amp;atk_text_info); 
   } 
   return type; 
} 
</programlisting>
</example>
-->
</section>

<section>
<title>Initialisierung von Klassen und Instanzen</title>
<para>Sie müssen einen Klassen-Initialisierer für das <type>GObject</type> implementieren, falls Ihre <type>AtkObject</type>-Implementierung entweder:</para>
<orderedlist>
<listitem>
<para>Funktionsaufrufe überschreibt, die vom Elternobjekt definiert sind. Dies ist für gewöhnlich notwendig, wenn ein Objekt eine Funktion wie <function>atk_object_get_n_accessible_children()</function> implementieren muss. Diese Funktion etwa muss implementiert werden, wenn das Objekt Kindelemente besitzt, die aber nicht durch Widgets dargestellt werden.</para>
<!--
<para>
For example, if your ATK implementation needs to over-ride the <type>AtkObject</type> function <function>get_name()</function>, then the class initializer would look like:
</para>
<example>
<title>Class initializer that overrides parent's <function>get_name()</function> function</title>
<programlisting>
myatkimp_mytype_class_init (GailLabelClass *klass) 
{ 
  AtkObjectClass *class = ATK_OBJECT_CLASS (klass); 
  class->get_name = myatkimp_mytype_get_name; 
} 
</programlisting>
</example>
-->
</listitem>
<listitem><para>Eine <function>parent-&gt;init</function>-, <function>parent-&gt;notify_gtk</function>- oder <function>parent-&gt;finalize</function>-Funktion benötigt.</para>
<!--
<para>
This example defines all three:
</para>
<example>
<title>Class initializer that defines its own <function>init()</function>, <function>notify_gtk()</function> and <function>finalize()</function> functions</title>
<programlisting>
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; 
}
</programlisting>
</example>
-->
<orderedlist>
<listitem>
<para>parent-&gt;init</para>
<para>Die Funktion <function>parent-&gt;init()</function> könnte erforderlich sein, wenn die ATK-Implementierung eine der folgenden Aufgaben besitzt:</para> 
<orderedlist>
<listitem>
<para>Daten vom einem begleitenden GTK-Widget zwischenspeichern (cache).</para>
</listitem>
<listitem>
<para>Signale des begleitenden GTK-Widgets abhören (listen).</para>
</listitem>
</orderedlist>
<!--
<para>
Here is an example of both:
</para>
<example>
<title>A custom <function>init()</function> function</title>
<programlisting>
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); 
} 
</programlisting>
</example>
<para>
In this example, if the specified <type>signal-type</type> signal were generated on the backing <varname>gtk_widget</varname>, then the <function>_myatkimp_mytype_signal_type()</function> function would be called.
</para>
-->
</listitem>
<listitem>
<para>parent-&gt;notify_gtk</para>
<para>Falls die ATK-Implementierung auf Änderungen einer Eigenschaft des begleitenden GTK-Widgets achten soll, könnte eine <function>parent-&gt;notify_gtk()</function>-Funktion notwendig sein. Zum Beispiel:</para>
<example>
<title>Eine benutzerdefinierte <function>notify_gtk()</function>-Funktion</title>
<programlisting>
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-&gt;name, "property-of-interest") == 0) 
   { 
      /* Handle the property change. */ 
   } 
   else 
   { 
      parent_class-&gt;notify_gtk (obj, pspec); 
   } 
} 
</programlisting>
</example>
</listitem>
<listitem>
<para>parent-&gt;finalize</para>
<para>Eine <function>finalize()</function>-Funktion ist erforderlich, wenn Daten freigegeben werden müssen, sobald eine <type>GObject</type>-Instanz zerstört wird. Zum Beispiel:</para>
<example>
<title>Eine benutzerdefinierte <function>finalize()</function>-Funktion</title>
<programlisting>
void 
myatkimp_mytype_finalize (GObject *object) 
{ 
   MyAtkimpMyType *my_type = MYATKIMP_MYTYPE (object); 

   g_object_unref (my_type-&gt;cached_value); 
   G_OBJECT_CLASS (parent_class)-&gt;finalize (object); 
} 
</programlisting>
</example>
</listitem>
</orderedlist>
</listitem>
</orderedlist>
</section>
</section>
</section>

<section id="gad-custom">
<title>Benutzerdefinierte Komponenten barrierefrei gestalten</title>
<para>Das Hinzufügen von ATK-Unterstützung zu Ihrem benutzerdefinierten Widget stellt die Zusammenarbeit mit der Barrierefreiheits-Infrastruktur sicher. Folgende grundlegende Schritte sind hierzu erforderlich:</para>
<itemizedlist>
<listitem>
<para>Ein benutzerdefiniertes Widget gemäß den dafür relevanten <link linkend="gad-ui-guidelines">Richtlinien für Benutzeroberflächen</link> beurteilen;</para>
</listitem>
<listitem>
<para>Herausfinden, welche <ulink url="https://developer.gnome.org/atk/stable/interfaces.html">ATK-Interfaces</ulink> ein benutzerdefiniertes Widget implementieren sollte, gemäß dem Funktionsumfang des Widgets;</para>
</listitem>
<listitem>
<para>Herausfinden, welche <ulink url="https://developer.gnome.org/atk/stable/interfaces.html">ATK-Interfaces</ulink> von der übergeordneten Klasse des Widgets geerbt werden können;</para>
</listitem>
<listitem>
<para>Die erforderlichen ATK-Interfaces für die Widgetklasse auf einem von zwei Wegen implementieren:</para>
<itemizedlist>
<listitem>
<para>Direkt in dem benutzerdefinierten Widget, oder</para>
</listitem>
<listitem>
<para>In einem Untertyp von <ulink url="https://developer.gnome.org/atk/stable/AtkObject.html"><type>AtkObject</type></ulink>, indem eine neue Unterklasse von <ulink url="https://developer.gnome.org/atk/stable/AtkObjectFactory.html"><type>AtkObjectFactory</type></ulink> erstellt wird</para>
</listitem>
</itemizedlist>
<para>Wenn die zweite Methode verwendet wird, muss der zugehörige Factory-Typ zur Laufzeit mit der <type>AtkObjectFactoryRegistry</type> registriert werden.</para>
</listitem>
</itemizedlist>
</section>

<section id="gad-ui-guidelines">
<title>Richtlinien für Benutzeroberflächen zur Unterstützung der Barrierefreiheit</title>
<para>Wenn Sie die Benutzeroberfläche Ihrer Anwendung entwerfen, gibt es eine Reihe einfacher Richtlinien, die Sie befolgen sollten, um die Anwendung möglichst vielen Nutzern zugänglich zu machen. Das gilt sowohl mit als auch ohne den Einsatz von Hilfstechnologien. Lassen Sie sich nicht täuschen: Es geht dabei nicht einfach darum, die Oberfläche auf Menschen mit Beeinträchtigung anzupassen und dass Sie die Richtlinien ignorieren können, wenn doch sowieso kein Mensch mit einer Beeinträchtigung Ihr Programm verwenden wird. Indem Sie die folgenden Richtlinien beachten, verbessern Sie die Bedienbarkeit Ihrer Anwendung für alle Nutzer - einschließlich Ihnen!</para>

<section>
<title>Allgemein</title>
<para>Wir alle sind frustriert, wenn wir eine Funktion in einem Programm nicht finden können, oder wenn das Programm einen Fehler macht, weshalb es eine Zeit lang braucht, um wieder zum Normalzustand zurückzukehren, wenn das überhaupt geht. Wenn Sie eine Beeinträchtigung besitzen, werden sowohl der Aufwand als auch die verschwendete Zeit dadurch häufig umso höher sein. Einigen Grundrichtlinien zu folgen, kann helfen, diese Situationen für alle Nutzer zu vermeiden.</para>
<itemizedlist>
<listitem>
<para>Stellen Sie eine Rückgängig-Funktion für jede Aktion bereit, welche die Benutzerdaten oder die Anwendugseinstellungen beeinflusst. Falls möglich, sollten für Rückgängig- und Wiederherstellungsfunktionen mehrere Schritte ermöglichen und eine Chronikansicht anbieten, die eine Vorschau auf rückgängig zu machende Aktionen enthält.</para>
</listitem>
<listitem>
<para>Stellen Sie Befehle zum Wiederherstellen von Standardeinstellungen bereit. Falls eine bestimmte Einstellung eine Anwendung für einen bestimmten Benutzer unbenutzbar machen könnte, beispielsweise durch eine viel zu kleine Schrift, dann kann eine Wiederherstellungsfunktion außerhalb der Anwendung sehr nützlich sein. Das kann zum Beispiel über einen entsprechenden Schalter in der Befehlszeile geschehen.</para>
</listitem>
<listitem>
<para>Verhindern Sie, dass der Benutzer das Falsche tut. Das ist insbesondere für Aktionen von Bedeutung, die versehentlich geschehen können (z.B. durch Mausbedienung) oder die nicht ohne Weiteres rückgängig gemacht werden können (z.B. Überschreiben von Dateien). Stellen Sie Informationsdialoge bereit oder zwingen Sie den Benutzer, gefährliche Aktionen nur in einem bestimmten Modus auszuführen.</para>
</listitem>
<listitem>
<para>Überstrapazieren Sie das Gedächtnis des Benutzers nicht. Lassen Sie den Benutzer beispielsweise mehrere Dokumente gleichzeitig betrachten und stellen Sie eine Online-Hilfe oder andere Hilfeanweisungen zur Verfügung, während die beschriebene Prozedur ausgeführt wird. Ermöglichen Sie das Kopieren jeglicher angezeigter Informationen und das Einfügen an beliebigen Stellen, wo Daten eingegeben werden können.</para>
</listitem>
<listitem>
<para>Lassen Sie den Benutzer keine Speichermedien einlegen. Abhängig von der jeweiligen Behinderung kann es schwierig sein, ein Medium physikalisch betrachtet einzulegen oder zu wechseln, oder das korrekte Medium richtig zu identifizieren. Falls Ihre Anwendung von CD-ROM installiert wird, sollten Sie dem Benutzer die Möglichkeit bieten, alle benötigten Dateien direkt auf die Festplatte zu kopieren.</para>
</listitem>
<listitem>
<para>Vergraben Sie häufig genutzte Funktionen nicht tief in einer Menüstruktur. Egal ob Sie eine Maus, die Tastatur oder ein anderes Eingabegerät verwenden, sollten tief ineinander verschachtelte Einträge besser vermieden werden. Da sich der Benutzer daran erinnern muss, wo diese zu finden sind, ist der Zugriff zu schwierig und erfordert zu viel Zeit.</para>
</listitem>
<listitem>
<para>Führen Sie den Benutzer nicht durch unnötige Schritte. Einrichtungsassistenten können zwar für Benutzer hilfreich sein, die Schwierigkeiten haben, mit vielen Optionen gleichzeitig umzugehen, aber andere wiederum möchten die Zeit oder die Anzahl der Tastenbedienungen minimieren. Solche Benutzer profitieren davon, nicht benötigte Schritte überspringen und direkt zum nächsten gewünschten Schritt gehen zu können. Stellen Sie in Ihrem Einrichtungsassistenten einen <guibutton>Finish</guibutton>-Knopf bereit, der direkt zum Ende des Assistenten führt und für die verbleibenden Schritte Standardwerte annimmt. Falls der Assistent aus sehr vielen Schritten besteht, sollten Sie den Benutzer zu Beginn fragen, ob alle diese Schritte angeboten werden oder nur diejenigen, die am häufigsten genutzt werden.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Tastatursteuerung</title>
<para>Eine gut durchdachte Tastaturschnittstelle spielt eine Schlüsselrolle beim Entwerfen barrierefreier Software. Blinde Benutzer können wesentlich effektiver mit der Tastatur navigieren, weil die Nutzung der Maus die visuelle Rückmeldung des Ortes des Mauszeigers erfordert. Auch Bewegungseinschränkungen können der Grund dafür sein, dass ein Benutzer erfolgreich mit der Maus navigieren kann, da dies von der Feinmotorik abhängt.</para>
<para>Es ist daher wichtig, dass alle Mausaktionen auch über die Tastatur erreichbar sind, einschließlich des Zugriffs auf alle Werkzeugleisten, Menüs, Verknüpfungen und Knöpfe. Jede von Ihrer Anwendung bereitgestellte Funktion sollte auch ausschließlich mit der Tastatur erreichbar sein. Legen Sie Ihre Maus besser zur Seite, wenn Sie Ihre Anwendung testen!</para>
<para>Die meiste Funktionalität lässt sich über Zugriffstasten und Tastenkürzel und die Navigationsfunktionen der Toolkits barrierefrei machen. Dennoch erfordern Vorgänge, die Ziehen-und-Ablegen beinhalten, weitere Überlegungen.</para>
<itemizedlist>
<listitem>
<para>Stellen Sie effizienten Zugriff auf alle Funktionen der Anwendung über die Tastatur her. Einige Benutzer könnten nicht in der Lage sein, eine Maus zu bedienen, und viele »Power-User« bevorzugen die Tastatur sowieso. Außerdem können spezialisierte Hilfstechnologien eher Tastaturereignisse als Mausereignisse simulieren. Da Tippen für einige Benutzer schwierig oder sogar schmerzhaft sein kann, ist eine Tastaturschnittstelle wichtig, welche die für eine gestellte Aufgabe nötige Anzahl der Tastaturzugriffe auf ein Minimum reduziert.</para>
</listitem>
<listitem>
<para>Verwenden Sie für die Tastaturnavigation eine logische Reihenfolge. Beim Navigieren durch Fensterinhalte mit der <keycap>Tabulatortaste</keycap> sollte die Bewegungsrichtung des Tastaturfokus voraussehbar sein. In westlichen Spracheinstellungen ist dies normalerweise von links nach rechts und von oben nach unten.</para>
</listitem>
<listitem>
<para>Stellen Sie die richtige Tabulator-Reihenfolge aller Bedienelemente sicher, deren Aktiv-Status von einem Ankreuzfeld, Auswahlknopf oder Umschaltknopf abhängt. Wenn solch ein Feld/Knopf ausgewählt ist, sollten alle vom ihm abhängigen Elemente aktiv und alle von anderen Feldern/Knöpfen abhängigen Elemente in der Gruppe inaktiv sein. Wenn der Benutzer ein Ankreuzfeld, einen Auswahlknopf oder Umschaltknopf auswählt, von dem anderen Elemente abhängen, sollten Sie nicht automatisch den Fokus auf das erste abhängige Element legen, sondern den Fokus bei dem Feld/Knopf selbst lassen.</para>
</listitem>
<listitem>
<para>Überschreiben Sie keine Barrierefreiheits-Funktionen des Systems. AccessX ist beispielsweise eine Erweiterung von XServer, die seit X11R6 unterstützt wird. Das Funktionsmerkmal »MouseKeys« (Maustasten) dieser Erweiterung ermöglicht es, Mausbewegungen und Anklicken von Knöpfen mit der Tastatur auszuführen. Implementieren Sie daher keine Funktionen, die nur per Tastendruck bedient werden können: Nutzer, die auf die MouseKeys-Funktion angewiesen sind, werden sie nicht nutzen können.</para>
</listitem>
<listitem>
<para>Bieten Sie wenn möglich mehrere Methoden an, Aufgaben mit der Tastatur auszuführen. Für manche Benutzer sind bestimmte Tasten und Tastenkombinationen leichter oder schwieriger als für andere.</para>
</listitem>
<listitem>
<para>Stellen Sie nach Möglichkeit immer sowohl die Bedienung mit Maus als auch Tastatur sicher. Einige Nutzer können nur von einer Variante Gebrauch machen.</para>
</listitem>
<listitem>
<para>Weisen Sie häufig benutzten Tastaturoperationen keine umständlichen, schwer zu erreichenden Tastenkombinationen zu. Einige Nutzer können die Tastatur nur mit einer Hand bedienen, weshalb Tastenkombinationen für typische Operationen bevorzugt werden sollten, die auch mit einer Hand zu aktivieren sind.</para>
</listitem>
<listitem>
<para>Vermeiden Sie, Tastenkombinationen häufig zu verwenden, bei denen man mehrere Tasten gleichzeitig drücken muss. Einige Nutzer können nicht mehrere Tasten gleichzeitig drücken und gedrückt halten. Hilfstechnologien wie AccessX können das zwar umgehen und in sequentielle Kombinationen umwandeln, dies erfordert aber natürlich mehr Zeit.</para>
</listitem>
<listitem>
<para>Stellen Sie sicher, dass mit der Maus auswählbarer Text auch mit der Tastatur ausgewählt werden kann. Davon profitieren alle Benutzer, aber besonders jene, deren Feinmotorik die genaue Maussteuerung erschwert.</para>
</listitem>
<listitem>
<para>Stellen Sie sicher, dass Objekte, die eine Größenänderung oder ein Verschieben per Ziehen-und-Ablegen mit der Maus ermöglichen, auch mit der Tastatur in der Größe geändert oder verschoben werden können. Dazu zählen etwa Symbole und Fenster auf dem Schreibtisch. Wo präzise Größenänderung und Platzierung potenziell wichtig ist, zum Beispiel in einem Diagramm, sollten Sie auch einen Dialog bereitstellen, in dem Koordinaten eingegeben werden können, oder eine Möglichkeit zum Einrasten von Objekten in einem benutzerdefinierten Raster.</para>
</listitem>
<listitem>
<para>Verwenden Sie keine allgemeinen Navigationsfunktionen zum Auslösen von Aktionen. Zum Beispiel sollten Sie in einem Dialog keine Tastaturnavigation per <keycap>Tabulatortaste</keycap> verwenden, um irgendwelche Aktionen auszulösen, die mit einem Bedienelement verknüpft sind.</para>
</listitem>
<listitem>
<para>Zeigen Sie durch die Tastatur ausgelöste Menüs, Fenster und Minihilfen nahe der Objekte an, auf die sie sich beziehen. In GNOME 2.0 können Nutzer Einblendmenüs mit <keycombo><keycap>Umschalttaste</keycap><keycap>F10</keycap></keycombo> aufrufen, sowie Minihilfen mit <keycombo><keycap>Umschalttaste</keycap><keycap>F1</keycap></keycombo>. Verbergen Sie das Objekt aber nicht vollständig, auf das sich das Menü oder die Minihilfe bezieht.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Maus-Interaktion</title>
<para>Denken Sie daran, dass nicht alle Benutzer mit der gleichen Geschicklichkeit eine Maus bedienen können und dass einige sogar Schwierigkeiten haben, den Mauszeiger zu sehen oder ihm zu folgen.</para>
<itemizedlist>
<listitem>
<para>Stellen Sie Alternativen für Klicks mit der mittleren und rechten Maustaste bereit. Diese können einerseits körperlich schwierig auszuführen sein, andererseits unterstützen einige Mäuse und viele Hilfstechnologien nur die primäre Maustaste. Manche Hilfstechnologien unterstützen sogar gar keine Maus, sondern erzeugen ausschließlich Tastaturereignisse.</para>
</listitem>
<listitem>
<para>Ermöglichen Sie den Abbruch sämtlicher Mausaktionen. Ein Druck auf die <keycap>Esc</keycap>-Taste sollte jede laufende Mausaktion abbrechen, zum Beispiel Ziehen und Ablegen einer Datei in der Dateiverwaltung oder Zeichnen einer Form in einem Zeichenprogramm.</para>
</listitem>
<listitem>
<para>Geben Sie während einer Ziehen-und-Ablegen-Aktion visuelle Rückmeldung. Wenn sich die Maus über möglichen Zielen befindet, heben Sie diese hervor und ändern den Mauszeiger. Verwenden Sie beim Überfahren unzulässiger Ablageziele den »Nicht-Ablegen«-Mauszeiger. Siehe <link linkend="gad-mouse-examples">Beispiele für Maus-Interaktionen</link>.</para>
</listitem>
<listitem>
<para>Bewegen Sie den Mauszeiger nicht automatisch oder beschränken ihn auf einen Teilbereich auf dem Bildschirm. Dies kann zu Problemen mit Hilfstechnologien führen, und ist auch für andere Nutzer verwirrend.</para>
</listitem>
<listitem>
<para>Ziele für die Maus sollten nicht zu klein sein. Im Allgemeinen sollte das Ziel für eine Maus mindestens so groß wie der Bereich um den Fensterrand im aktuellen Fenstermanager/Thema herum, innerhalb dessen man die Fenstergröße ändern kann. Bedenken Sie, dass ein Nutzer mit eingeschränkter Geschicklichkeit oder Sehstärke einen Fenstermanager mit größeren Bereichen verwenden könnte.</para>
</listitem>
</itemizedlist>

<section id="gad-mouse-examples">
<title>Beispiele für Maus-Interaktionen</title>
<figure>
<title>Beispiel eines »Nicht-Ablegen«-Zeigers aus CDE/Motif</title>
<mediaobject><imageobject> <imagedata fileref="figures/nodrop.png" format="PNG"/> </imageobject> <textobject> <phrase>Beispiel für eine Form des Mauszeigers für »Nicht-Ablegen«</phrase> </textobject></mediaobject>
</figure>
</section>
</section>

<section>
<title>Grafische Elemente</title>
<para>Stellen Sie Optionen bereit, die Darstellung aller wichtigen grafischen Elemente in Ihrer Anwendung anzupassen. Dies erleichtert Benutzern mit Sehschwäche oder kognitiven Störungen die Bedienung.</para>
<itemizedlist>
<listitem>
<para>Grafische Attribute wie die Stärke von Linien, Rändern oder Schatten sollte nicht unveränderlich im Quellcode festgelegt werden (hardcoden). Diese Elemente sollten idealerweise vom GTK- oder Fenstermanager-Thema ausgelesen werden können. Falls das nicht möglich ist, bieten Sie Einstellungen in Ihrer Anwendung an, mit denen man diese Attribute anpassen kann.</para>
</listitem>
<listitem>
<para>Stellen Sie Beschreibungen für alle Oberflächenelemente bereit. GTK bietet zwar barrierefreie Standard-Beschreibungen für viele GTK-Widgets, Sie werden aber in einigen Fällen dennoch eigene hinzufügen müssen. Ein Beispiel dafür sind Widgets, die Grafiken statt Text verwenden, zum Beispiel ein Symbol ohne Beschriftung. Überlegen Sie auch, ob Sie die Standard-Beschreibungen durch hilfreichere oder Anwendungsbezogene Beschreibungen ersetzen können.</para>
</listitem>
<listitem>
<para>Erlauben Sie, dass mehrfarbige grafische Elemente (z.B. Werkzeugleisten-Symbole) auch monochrom dargestellt werden können. Die monochromen Bilder sollten in den Vorder- und Hintergrundfarben des Systems dargestellt werden, da der Benutzer diese über das GTK-Thema für sich einstellen kann. Dies ermöglicht maximale Lesbarkeit.</para>
</listitem>
<listitem>
<para>Interaktive Oberflächenelemente sollten gut erkennbar sein. Ein Benutzer sollte beispielsweise nicht erst die Maus über ein Objekt ziehen müssen, um zu erkennen, ob er es anklicken kann oder nicht. Lassen Sie ausreichend Platz zwischen Objekten und grenzen Sie Objekte klar voneinander ab. Zeigen Sie keine Elemente in der Benutzeroberfläche an, die zwar hübsch aussehen, aber nichts bewirken und nicht deaktiviert werden können.</para>
</listitem>
<listitem>
<para>Stellen Sie eine Einstellung bereit, um Grafiken zu deaktivieren, die keine essentiellen Informationen beinhalten. Grafiken können Benutzer mit kognitiven Einschränkungen irritieren. Die Symbole in der GNOME-Fußleiste können abgeschaltet werden, ohne dass die Funktionalität darunter leidet.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Schriften und Text</title>
<para>Textausgaben nehmen für gewöhnlich den größten Teil der Informationen und Rückmeldungen einer Anwendung ein, auch für Benutzer mit normaler Sehkraft. Umso wichtiger ist es, Textfelder richtig auf dem Bildschirm zu positioneren und dem Benutzer die Wahl der Schriftart und -Größe zu überlassen. Letzteres erlaubt auch Nutzern mit eingeschränkter Sehkraft, Ihre Anwendung effektiv zu nutzen.</para>
<itemizedlist>
<listitem>
<para>Legen Sie Schriftart und -Größe nicht unveränderlich fest. Der Benutzer sollte in der Lage sein, alle Größen und Schriftarten anzupassen. Falls Sie aus irgendwelchen Gründen nicht dazu in der Lage sind, stellen sie keine Schriftgrößen kleiner als 10 Punkt ein.</para>
</listitem>
<listitem>
<para>Stellen Sie Einstellungen bereit, grafische Hintergründe oder Wasserzeichen hinter Text zu entfernen. Diese Bilder verringern unter Umständen den Kontrast zwischen Text und Hintergrund, und können für Nutzer mit visuellen Einschränkungen Probleme bereiten.</para>
</listitem>
<listitem>
<para>Beschriften Sie Objekte mit Namen, sodass diese auch außerhalb des Kontexts Sinn ergeben. Benutzer, die Bildschirmleser oder ähnliche Hilfstechnologien verwenden, sehen eventuell nicht unmittelbar den Zusammenhang zwischen Bedienelementen.</para>
</listitem>
<listitem>
<para>Verwenden Sie nicht die gleiche Beschriftung für mehrere Elemente auf dem gleichen Fenster. Sie können den gleichen Namen in unterschiedlichen Fenstern verwenden, wenn er die gleiche Bedeutung besitzt. Verwenden Sie auch keine Beschriftungen, die unterschiedlich geschrieben, aber gleich ausgesprochen werden, zum Beispiel »Read« und »Red«. Dies kann Nutzer mit Bildschirmlesern verwirren.</para>
</listitem>
<listitem>
<para>Bleiben Sie konsistent bei der Platzierung Ihrer Beschriftungen. Für gewöhnlich bedeutet dies, dass Beschriftungen direkt unterhalb von großen Symbolen, rechts von kleinen Symbolen und links oder oberhalb von anderen Bedienelementen platziert werden. Weitere Beispiele finden Sie unter <link linkend="gad-font-examples">Beispiele für Schriften und Text</link>.</para>
</listitem>
<listitem>
<para>Wenn Sie statischen Text verwenden, um ein Bedienelement zu beschriften, beenden Sie die Beschriftung mit einem Doppelpunkt. Verwenden Sie zum Beispiel <guilabel>Username:</guilabel>, um eine Texteingabe zu beschriften, in die der Nutzer seinen Benutzernamen eingeben soll. Das hilft beim Verständnis, dass es sich bei dem Objekt um ein Bedienelement handelt statt um ein unabhängiges Textfeld.</para>
</listitem>
<listitem>
<para>Wenn Sie statischen Text verwenden, um ein Bedienelement zu beschriften, stellen Sie sicher, dass die Beschriftung in der Tabulator-Reihenfolge unmittelbar vor dem Bedienelement liegt. Dadurch gewährleisten Sie, dass das der Beschriftung zugeordnete Mnemonic auch zu dem richtigen Bedienelement springt bzw. es aktiviert.</para>
</listitem>
<listitem>
<para>Ermöglichen Sie Alternativen zu WYSIWYG (»What You See Is What You Get«, zu deutsch etwa »Was du siehst, ist, was du bekommst«). Einige Benutzer können Text nur in einer hohen Schriftgröße bearbeiten, wollen ihn aber kleiner drucken. Mögliche Alternativen wären, den gesamten Text in der gleichen Schriftart und -größe darzustellen (welche vom Benutzer eingestellt werden können); Eine Einstellung »Text am Fenster umbrechen«, mit der der ganze Text gelesen werden kann, ohne waagerecht rollen zu müssen; eine Einstellung, mit der alle Fensterinhalte in einer einzelnen Spalte dargestellt werden, selbst wenn sie in mehreren Spalten gedruckt werden; sowie ein Text-Modus, in dem Grafiken als Platzhalter oder Textbeschreibungen dargestellt werden. Besitzt die Anwendung Leisten mit Unterelementen, sollten Sie erwägen, die Leisten gemeinsam mit dem übergeordneten Fenster zu vergrößern bzw. verkleinern.</para>
</listitem>
</itemizedlist>

<section id="gad-font-examples">
<title>Beispiele für Schriften und Text</title>
<figure id="label-placement-example">
<title>Richtige Platzierung der Beschriftung bei verschiedenen Bedienelementen</title>
<informaltable frame="all">
<tgroup cols="3" align="center">
<tbody>
<row>
<entry valign="middle"><mediaobject>
<imageobject>
<imagedata fileref="figures/label_above.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>List control with label above</phrase>
</textobject>
</mediaobject> Listenansicht mit Beschriftung oben</entry>
<entry valign="middle"><mediaobject>
<imageobject>
<imagedata fileref="figures/label_below.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Large file manager icon with label underneath</phrase>
</textobject>
</mediaobject> Großes Dateiverwaltung-Symbol mit Beschriftung unten</entry>
<entry valign="middle"><mediaobject>
<imageobject>
<imagedata fileref="figures/label_right.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Small toolbar icon with label to its right</phrase>
</textobject>
</mediaobject> Kleines Werkzeugleistensymbol mit Beschriftung rechts</entry>
<entry valign="middle"><mediaobject>
<imageobject>
<imagedata fileref="figures/label_left.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Spinbox control with label to its left</phrase>
</textobject>
</mediaobject> Einstellfeld mit Beschriftung links</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</figure>
</section>
</section>

<section>
<title>Farbe und Kontrast</title>      
<para>Eine schlechte Farbauswahl auf dem Bildschirm kann für farbenblinde Benutzer (für die der Farbton wichtig ist) und Benutzer mit Sehbehinderung (für die Helligkeit und Kontrast wichtig sind) zu Problemen führen. Achten Sie grundsätzlich darauf, dass Nutzer überall dort Farben ändern können, wo diese wichtige Informationen übermitteln.</para>
<para>Benutzer mit visuellen Einschränkungen benötigen unter Umständen einen hohen Kontrast zwischen dem Hintergrund und Textfarben. Häufig wird ein schwarzer Hintergrund und weiße Schrift verwendet, damit der Hintergrund nicht überläuft. Diese Einstellung ist für Nutzer mit einer Sehschwäche jedoch kritisch.</para>
<itemizedlist>
<listitem>
<para>Legen sie Anwendungsfarben nicht unveränderlich im Programmcode fest. Einige Nutzer benötigen bestimmte Farb- und Kontrastkombinationen, damit sie den Bildschirm gut lesen können. Übernehmen Sie alle Hauptfarben in Ihrer GNOME-Anwendung daher vom GTK-Thema, damit der Nutzer darüber die Farben für alle Anwendungen für sich optimieren kann. Wenn Sie aus irgendwelchen Gründen Farben benötigen, die nicht im Thema verfügbar sind, stellen Sie Optionen innerhalb der Anwendung bereit, über die sie der Nutzer anpassen kann.</para>
</listitem>
<listitem>
<para>Verwenden Sie Farben nicht als einziges Mittel, um Informationsblöcke voneinander zu trennen. Verwenden Sie mindestens ein weiteres Trennmerkmal wie etwa Form, Position oder Textbeschreibung. Weitere Informationen finden Sie unter <link linkend="gad-color-examples">Beispiele für Farbe und Kontrast</link>.</para>
</listitem>
<listitem>
<para>Unterstützen Sie alle Hochkontrast-Themen von GNOME. Wenn eines dieser Themen aktiviert ist, sollten Sie sicherstellen, dass all Ihr Anwendungstext in den kontrastreichen Vorder- und Hintergrundfarben des Themas dargestellt wird.</para>
</listitem>
<listitem>
<para>Stellen Sie sicher, dass Ihre Anwendung kein bestimmtes Thema mit hohem Kontrast benötigt. Testen Sie sie mit verschiedenen Hochkontrast-Themen, um sicher zu stellen, dass Ihre Anwendung die Einstellungen respektiert.</para>
</listitem>
</itemizedlist>

<section id="gad-color-examples">
<title>Beispiele für Farbe und Kontrast</title>
<example>
<title>Beispiel für die redundante Farbverwendung</title>
<informaltable frame="all">
<tgroup cols="2">
<tbody>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/color_only.png" format="PNG"/> </imageobject> <textobject> <phrase>Beispiel, in dem Änderungen im Börsenkurs nur durch die Farbe dargestellt werden</phrase> </textobject></mediaobject>
</entry>
<entry>Diese Anzeige könnte farbenblinden Benutzern mit einer Rot-Grün-Schwäche Probleme bereiten. Diese Art der Farbenblindheit betrifft in einigen Teilen der Welt ein Siebtel der Männer. Durch den mangelnden Kontrast zwischen dem roten Text und dem schwarzen Hintergrund ist die Lesbarkeit auch für Sehbehinderte beeinträchtigt, selbst unter Zuhilfenahme einer Bildschirmlupe.</entry>
</row>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/color_and_arrows.png" format="PNG"/> </imageobject> <textobject> <phrase>Beispiel, in dem Änderungen im Börsenkurs sowohl durch die Farbe also auch durch Pfeile dargestellt werden</phrase> </textobject></mediaobject>
</entry>
<entry>Diese Anzeige verwendet zusätzlich zur Farbgebung noch Pfeile, um Bewegungen im Börsenkurs darzustellen. Auch werden dunklere Rot- und Grün-Farbtöne auf einem hellen Hintergrund verwendet, wodurch sich ein höherer Kontrast ergibt. Hierbei muss es sich nicht um das Standard-Farbschema handeln, wenn es den Großteil der Nutzer ablenkt. Es sollte aber möglich sein, es auf diese Weise anzupassen, entweder über ein Thema oder über den <guilabel>Preferences</guilabel>-Dialog der Anwendung.</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</example>
</section>
</section>

<section>
<title>Vergrößerung</title>
<para>Viele Benutzer profitieren von der Vergrößerung von Text und Grafiken, selbst jene Benutzer ohne Sehbehinderung. Ohne Vergrößerung könnte ein sehbehinderter Benutzer möglicherweise überhaupt nicht in der Lage sein, Ihr Programm zu verwenden.</para>
<itemizedlist>
<listitem>
<para>Geben Sie dem Benutzer die Möglichkeit, den Arbeitsbereich zu vergrößern.</para>
</listitem>
<listitem>
<para>Ermöglichen Sie, die Größe des Arbeitsbereiches Ihrer Anwendung zu verändern. Benutzer sollten den Arbeitsbereich auf 150-400% oder mehr vergrößern können. Testen sie Ihre Anwendung, um zu überprüfen, dass die Darstellung des betrachteten Objekts nicht durch die Vergrößerungseinstellung beeinträchtigt wird.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Klänge</title>
<para>Sowohl Leute mit eingeschränktem Hörvermögen als auch Benutzer, die Klänge auf Ihrem Rechner generell abgeschaltet haben, dürften nicht begeistert sein, wenn Ihre Anwendung Informationen allgemein über Klangausgaben bereitstellt. Stellen Sie sicher, dass der Benutzer in der Lage ist, als Klang ausgegebene Informationen auch auf anderen Wegen zu erhalten.</para>
<itemizedlist>
<listitem>
<para>Nehmen Sie nicht einfach an, dass ein Benutzer Klänge hören will. Das betrifft sowohl Benutzer mit defekten Soundkarten als auch Hörgeschädigte!</para>
</listitem>
<listitem>
<para>Betrachten Sie Klänge nicht als den einzigen Weg, Informationen bereitzustellen. Geben Sie dem Benutzer die Möglichkeit, alle Klanginformationen auch visuell darstellen zu können. Dies beinhaltet geschlossene Beschriftungen und Textausgaben von allen wichtigen gesprochenen Soundclips.</para>
</listitem>
<listitem>
<para>Ermöglichen Sie dem Benutzer, die Frequenz und die Lautstärke alle Warntöne und sonstigen Klänge einzustellen. Die Klänge sollten auch vollständig abschaltbar sein.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Animation</title>
<para>Sparsam verwendet, können Animationen durchaus nützlich zur Darstellung wichtiger Informationen in Ihrer Anwendung sein - und sie können natürlich auch cool aussehen. Allerdings können sie für bestimmte Benutzer auch problematisch sein, daher sollten Sie eine Möglichkeit vorsehen, die Animationen abzuschalten.</para>
<itemizedlist>
<listitem>
<para>Verwenden Sie keine blitzenden oder blinkenden Elemente mit einer Frequenz oberhalb von 2 Hz und unterhalb von 55 Hz. Dies betrifft sowohl Text als auch jegliche grafische Objekte. Alles innerhalb dieses Frequenzbereichs kann Benutzern mit Sehbehinderungen Probleme bereiten. Denken Sie daran, dass es keine »sichere« Frequenz gibt. Falls Blinken von essenzieller Bedeutung ist, dann sollten Sie die Blinkfrequenz des Systemzeigers verwenden (die an sich schon konfigurierbar ist) oder den Benutzern ermöglichen, eine eigene Frequenz festzulegen.</para>
</listitem>
<listitem>
<para>Lassen Sie keine größeren Bereiche des Bildschirms blitzen oder blinken. Kleine Bereiche verursachen weit weniger Probleme für Benutzer mit Sehbehinderungen.</para>
</listitem>
<listitem>
<para>Alle Animationen sollten optional sein. Animierte Informationen sollten auch in mindestens einem nicht-animierten Format zur Verfügung gestellt werden können, wenn der Benutzer es wünscht.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Tastaturfokus</title>
<para>Die Position des Tastaturfokus jederzeit anzuzeigen ist nicht nur für Nutzer mit einer Sehbehinderung wichtig, sondern auch für »Power-User«, die lieber mit der Tastatur als der Maus arbeiten. Es sollte niemals unklar sein, welches Bedienelement auf dem Bildschirm gerade im Fokus steht. Der Benutzer sollte in der Lage sein, den Rechner zu verlassen und mit Freunden zu telefonieren oder dem Hund rauszugehen, bis er vergessen hat, woran er gearbeitet hat. Wenn er dann zurückkommt, sollte er sich unmittelbar wieder einfinden können, wo er stehen geblieben ist.</para>
<para>Ein visueller Fokusindikator ist eine akustische Repräsentation der Position der Tastatur-Eingabemarke im Verhältnis zu den übrigen Objekten auf dem Bildschirm. Er erlaubt Nutzern, zwischen Objekten interaktiv zu navigieren, während sich der Fokus ändert. Der visuelle Fokus muss programmatisch von Hilfstechnologien aufgegriffen werden können. Meistens wird dies automatisch von ATK erledigt, ohne dass sie selbst Hand anlegen müssen. Sie sollten sich dessen aber bewusst sein, etwa wenn Sie ein benutzerdefiniertes Widget programmieren.</para>
<itemizedlist>
<listitem>
<para>Der Fokus sollte anfangs bei dem Bedienelement liegen, das am häufigsten verwendet wird. Gibt es solch ein »häufigstes« Element nicht, legen Sie den anfänglichen Fokus auf das erste Element im Fenster, wenn das Fenster geöffnet wird. Der Fokus sollte nicht bei den Knöpfen <guilabel>OK</guilabel> oder <guilabel>Cancel</guilabel> im Dialog starten, auch wenn sie die am häufigsten verwendeten Elemente sind, da man diese jederzeit per Tastendruck auf die <keycap>Eingabetaste</keycap> oder <keycap>Escape</keycap> aktiveren kann.</para>
</listitem>
<listitem>
<para>Zeigen Sie den aktuellen Eingabefokus jederzeit deutlich an. Denken Sie dran, dass es Bedienelementen mit einer Bildlaufleiste nicht nur genügt, das aktuell ausgewählte Element anzuzeigen, da dieses nicht immer sichtbar sein könnte. Ein Beispiel dazu finden Sie unter <link linkend="gad-focus-examples">Beispiele für den Tastaturfokus</link>.</para>
</listitem>
<listitem>
<para>Nur im aktiven Fenster sollte der Eingabefokus angezeigt werden. Verdecken Sie alle primären, visuellen Fokusindikatoren in allen Fenster, die nicht gerade aktiv sind und im Fokus stehen. Wenn ein Fenster mehrere Bereiche besitzt, sollte nur ein Bereich den Fokusindikator haben. In den übrigen Bereichen sollte der Indikator verdeckt sein. Falls es wichtig ist, dass das ausgewählte Element in einer nicht-fokussierten Liste angezeigt wird, können Sie einen zweiten Fokusindikator verwenden. Ein Beispiel dazu finden Sie unter <link linkend="gad-focus-examples">Beispiele für den Tastaturfokus</link>.</para>
</listitem>
<listitem>
<para>Bieten Sie ausreichend Feedback, wenn der Benutzer versucht, aus einer logischen Gruppe von Objekten heraus zu navigieren. Wenn der Benutzer etwa durch eine Liste navigiert und am letzten Element angelangt ist, sollten Sie ihm eher einen Hinweiston abspielen, als einfach den Fokus wieder auf das erste Element der Liste zu legen. Blinde Nutzer oder solche mit einer schwachen Sehkraft könnten anderenfalls nicht realisieren, dass sie wieder am Anfang angelangt sind. Bei einer Textsuche in einem Dokument können Sie einen Dialog anzeigen lassen, wenn Sie am Ende angelangt sind und fragen, ob der Nutzer die Suche wieder am Anfang starten möchte.</para>
</listitem>
<listitem>
<para>Spielen Sie die Standardklänge des Systems ab oder geben Sie visuelle Warnsymbole, wenn der Benutzer eine ungültige Taste drückt oder wenn eine Navigationstaste den Fokus nicht verschieben kann. Beispiele dazu wären, wenn der Fokus auf dem ersten Zeichen in einem Text liegt und der Nutzer die linke Pfeiltaste drückt, oder wenn er versucht, eine Mehrfachauswahl in einem Einfachauswahl-Dialog zu treffen. (Bedenken Sie dabei, dass Benutzer mit Hörproblemen dazu in der Lage sein sollten, systemweit eine visuelle Alternative zu dem Standard-Warnton einzustellen.)</para>
</listitem>
</itemizedlist>

<section id="gad-focus-examples">
<title>Beispiele für den Tastaturfokus</title>
<example><title>Beispiel zur Verdeutlichung, wie wichtig ein eindeutiger Tastaturfokus ist</title>
<informaltable frame="all">
<tgroup cols="2">
<tbody>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/badfocus1.png" format="PNG"/> </imageobject> <textobject> <phrase>Das fokussierte Element in diesem Fenster ist außerhalb des sichtbaren Bereichs</phrase> </textobject></mediaobject>
</entry>
<entry>Eines der Elemente in diesem Fenster ist fokussiert, aber es ist unmöglich zu sagen, welches …</entry>
</row>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/badfocus2.png" format="PNG"/> </imageobject> <textobject> <phrase>Das fokussierte Element in der Liste ist jetzt sichtbar, weil die Liste runtergerollt wurde</phrase> </textobject></mediaobject>
</entry>
<entry>… bis man die Liste rollt, wodurch erkenntlich wird, dass ein Listenelement ausgewählt ist.</entry>
</row>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/goodfocus.png" format="PNG"/> </imageobject> <textobject> <phrase>Die Liste in diesem Beispiel besitzt einen kräftigen Rand, der den Fokus indiziert, selbst wenn das ausgewählte Listenelement nicht im sichtbaren Bereich liegt</phrase> </textobject></mediaobject>
</entry>
<entry>Wenn die Liste selbst einen »Fokus«-Rand besitzt, ist klar, dass auf ihm gerade der Fokus liegt, selbst das aktuell ausgewählte Listenelement gerade nicht sichtbar ist.</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</example>
<example>
<title>Beispiel für die Nutzung eines sekundären Fokus</title>
<informaltable frame="all">
<tgroup cols="2">
<tbody>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/badfocus3.png" format="PNG"/> </imageobject> <textobject> <phrase>Aufgeteiltes Fenster mit zwei Bereichen, in denen beide Bereiche fokussiert zu sein scheinen</phrase> </textobject></mediaobject>
</entry>
<entry>In diesem Beispiel ist visuell nicht erkennbar, welcher Bereich gerade den tatsächlichen Tastaturfokus besitzt</entry>
</row>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/goodfocus3.png" format="PNG"/> </imageobject> <textobject> <phrase>Aufgeteiltes Fenster, in dem eine sekundäre Hervorhebung genutzt wird, um zu verdeutlichen, welcher Bereich gerade den Fokus besitzt</phrase> </textobject></mediaobject>
</entry>
<entry>Indem eine sekundäre Hervorhebungsfarbe im inaktiven Bereich verwendet wird, ist unmittelbar klar, dass hier das Baumelement den Fokus besitzt …</entry>
</row>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/goodfocus2.png" format="PNG"/> </imageobject> <textobject> <phrase>Aufgeteiltes Fenster, in dem eine sekundäre Hervorhebung genutzt wird, um zu verdeutlichen, welcher Bereich gerade den Fokus besitzt</phrase> </textobject></mediaobject>
</entry>
<entry>… und hier das Listenelement den Fokus besitzt.</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</example>
</section>
</section>

<section>
<title>Zeitabläufe</title>
<para>Oberflächen, in denen Dinge abhängig von festen Zeiten erscheinen oder verschwinden, sind schlecht für die Barrierefreiheit. Einige Nutzer können nur sehr langsam reden, tippen und auf Änderungen reagieren. Wenn benötigte Informationen für sie zu schnell verschwinden oder durch neue Informationen verdeckt werden, die sie nicht ausdrücklich angefordert haben, wird Ihre Anwendung bei diesen Nutzern Frust erzeugen oder kann überhaupt nicht verwendet werden.</para>
<itemizedlist>
<listitem>
<para>Schreiben Sie Zeitüberschreitungen und andere zeitbasierte Funktionen nicht fest in den Quellcode. Dazu gehören etwas das automatische Rollen, wenn ein Objekt an die Nähe des Fensterrands gezogen wird, wenn der Knopf einer Bildlaufleiste gehalten wird, oder wenn sich ein Baumelement automatisch ausklappt, wenn ein Objekt eine kurze Zeit lang darüber gezogen und gehalten wird. Diese Zeiten sollten entweder in der Anwendung, den GNOME-Einstellungen oder wenigstens über die Befehlszeile per Konfigurationsdatei oder GConf-Eintrag einstellbar sein.</para>
</listitem>
<listitem>
<para>Informationen sollten nicht abhängig von der Bewegung des Mauszeigers nur kurz angezeigt oder verdeckt werden. (Ausnahme: Systemfunktionen wie Minihilfen, die systemweit konfiguriert werden können). Wenn Sie solche Funktionen benötigen, sollten Sie eine Option bereitstellen, über die der Nutzer sie deaktivieren kann, wenn ein Bildschirmleser installiert ist.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Dokumentation</title>
<para>Menschen mit Behinderungen können Ihre Anwendung nicht effektiv nutzen, wenn Sie keinen Zugriff auf die benötigten Handbücher und Hilfedateien haben. Besonders wichtig ist die Tastaturnavigation, da viele Nutzer nur darüber die Anwendung bedienen können.</para>
<itemizedlist>
<listitem>
<para>Stellen Sie Ihre Dokumentation barrierefrei bereit. Hilfstechnologien können zum Beispiel sehr gut mit ASCII-Text und HTML umgehen.</para>
</listitem>
<listitem>
<para>Grafiken in Ihrer Dokumentation sollten alternative Textbeschreibungen besitzen.</para>
</listitem>
<listitem>
<para>Dokumentieren Sie die barrierefreien Funktionen Ihrer Anwendung. Tastaturnavigation und Tastenkürzel sind besonders wichtig zu dokumentieren. Schreiben Sie einen Barrierefreiheit-Abschnitt in Ihrer Dokumentation, in dem Informationen zu allen barrierefreien Funktionen zu finden sind.</para>
</listitem>
</itemizedlist>
</section>
</section>
</chapter>

<chapter id="gtest" status="draft">
<title>Testen</title>
<para>Bevor Sie eine Anwendung als barrierefrei deklarieren, sollten Sie mehrere Dinge überprüfen. Im Laufe der Entwicklung sollten Sie automatisierte Tests in Betracht ziehen. Zum Beispiel könnte <ulink url="http://ldtp.freedesktop.org/">LDTP</ulink> Ihre automatischen Tests ergänzen.</para>
<para>Dieser Abschnitt beschreibt eine Anzahl von Tests, die Sie manuell in einer Anwendung ausführen können, um deren Barrierefreiheit zu überprüfen. Das erfolgreiche Durchlaufen dieser Tests gewährleistet zwar nicht zwangsläufig, dass die Anwendung vollständig barrierefrei ist. Aber falls Ihre Anwendung an einem dieser Tests scheitert, dann sind weitere Aktionen notwendig, um die Barrierefreiheit zu verbessern.</para>

<section>
<title>Tastatursteuerung</title>
<para>Die folgenden Tastaturoperationen sollten überprüft werden. Benutzen Sie in keinem Teil dieses Tests die Maus.</para>
<itemizedlist>
<listitem>
<para>Bewegen Sie den Fokus durch alle Menüleisten in der Anwendung und verwenden Sie dazu nur Tastaturbefehle.</para>
</listitem>
<listitem>
<para>Überprüfen Sie, ob:</para>
<itemizedlist>
<listitem>
<para>kontextabhängige Menüs korrekt dargestellt werden.</para>
</listitem>
<listitem>
<para>jegliche in der Werkzeugleiste sichtbare Funktionen auch über die Tastatur erreichbar sind.</para>
</listitem>
<listitem>
<para>Sie jedes Bedienelement im Anwender-Bereich der Anwendung und in Dialogfeldern ansprechen können.</para>
</listitem>
<listitem>
<para>Text und Objekte im Anwender-Bereich ausgewählt werden können.</para>
</listitem>
<listitem>
<para>alle Tastenkombinationen und Schnellzugriffe so funktionieren, wie gewünscht.</para>
</listitem>
</itemizedlist>
</listitem>
</itemizedlist>
</section>

<section>
<title>Grafische Elemente</title>
<para>Testen Sie Ihre Anwendung mit einem Bildschirmleser und überprüfen Sie, ob:</para>
<itemizedlist>
<listitem>
<para>Beschriftung und Text korrekt gelesen werden, einschließlich in Menüs und Werkzeugleisten.</para>
</listitem>
<listitem>
<para>Objektinformationen korrekt gelesen werden.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Indikator für den visuellen Fokus</title>
<itemizedlist>
<listitem>
<para>Überprüfen Sie, ob der Indikator für den visuellen Fokus beim Bewegen durch die Objekte einfach zu erkennen ist.</para>
</listitem>
<listitem>
<para>Die Tastatur-Navigation durch die Software und deren Menüs sollte deutlich sichtbar sein, wenn sich der Fokus verändert.</para>
</listitem>
<listitem>
<para>Überprüfen Sie, ob der Bildschirmleser den Indikator für den visuellen Fokus verfolgt, wenn Sie eine Tastatur verwenden.</para>
</listitem>
<listitem>
<para>Führen Sie ein Programm zur Vergrößerung der Bildschirminhalte aus (eine Bildschirmlupe), um sicherzustellen, dass die Bildschirmlupe den Indikator für den visuellen Fokus verfolgt, wenn Sie die Tastatur oder die Maus verwenden.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Schriften und Text</title>
<itemizedlist>
<listitem>
<para>Ändern Sie die Schrift in der Anwendung und überprüfen Sie, ob die Einstellungen angewendet werden.</para>
</listitem>
<listitem>
<para>Testen Sie die Anwendung, indem Sie die Farben ändern und überprüfen, ob die Einstellungen wirksam werden.</para>
</listitem>
<listitem>
<para>Falls Vergrößerung verfügbar ist, dann überprüfen Sie die Schrift, die Farbe und die Größe der Vergrößerungsoption.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Farbe und Kontrast</title>
<itemizedlist>
<listitem>
<para>Drucken Sie Bildschirmfotos mit einem einfarbigen Drucker aus und überprüfen Sie, ob alle Informationen sichtbar sind.</para>
</listitem>
<listitem>
<para>Testen Sie Anwendungen in einer schwarzweißen Darstellung mit hohem Kontrast und überprüfen Sie, ob alle Informationen korrekt vermittelt werden.</para>
</listitem>
<listitem>
<para>Testen Sie Ihre Anwendung daraufhin, ob sie mindestens drei Farbkombinationen als Thema unterstützt und dass Schemata in hohem Kontrast verfügbar sind, beispielsweise weiß auf schwarz oder gelb auf blau.</para>
</listitem>
<listitem>
<para>Schalten Sie im GNOME-Kontrollzentrum die Einstellungen zu hohem Kontrast ein und überprüfen Sie, ob Ihre Anwendung diese Einstellungen berücksichtigt.</para>
</listitem>
<listitem>
<para>Testen Sie verschiedene Themen, um sicherzustellen, dass die Software mit allen verfügbaren Einstellungen funktioniert.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Klänge</title>
<para>Es sollte in der Anwendung eine Option geben, um akustische Benachrichtigungen visuell darstellen zu lassen.</para>
<para>Überprüfen Sie, ob die Ausgabe von Klängen korrekt funktioniert, indem Sie diese im GNOME-Kontrollzentrum einschalten und dann folgende Aktionen ausführen:</para>
<itemizedlist>
<listitem>
<para>Führen Sie eine Aktion aus, die eine akustische Warnung auslöst und überprüfen Sie, ob die Anwendung wie erwartet funktioniert.</para>
</listitem>
<listitem>
<para>Stellen Sie sicher, dass Ihre Anwendung korrekt reagiert, wenn Sie die Lautstärke erhöhen oder verringern.</para>
</listitem>
<listitem>
<para>Überprüfen Sie, ob Warnmeldungen auch in einer lauteren Umgebung korrekt verstanden werden können.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Animation</title>
<para>Stellen Sie sicher, dass eine Option zum Abschalten von Animationen zur Verfügung steht und diese wie erwartet funktioniert.</para>
<para>Schalten Sie die Animationen ab. Überprüfen Sie, ob alle Informationen immer noch korrekt vermittelt werden können.</para>
</section>

<section>
<title>Tastaturfokus</title>
<itemizedlist>
<listitem>
<para>Testen Sie alle Meldungen, um zu überprüfen, ob der Benutzer ausreichend benachrichtigt werden kann, bevor eine Meldung verschwindet, mit der Option anzugeben, dass mehr Zeit notwendig ist.</para>
</listitem>
<listitem>
<para>Stellen Sie sicher, dass eine Option zum Einstellen der Antwortzeit verfügbar ist und diese wie erwartet funktioniert.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Dokumentation</title>
<para>Testen Sie Dokumentation im ASCII-Format mit einem Bildschirmleser, um sicherzustellen, dass diese klar und präzise von Hilfstechnologien gelesen werden kann.</para>
<para>Testen Sie HTML-Anwendungen mit einem Webbrowser und Bildschirmleser, um zu überprüfen, ob die Dokumentation barrierefrei ist und durch Hilfstechnologien verarbeitet werden kann.</para>
<para>Hinweis: Es gibt Richtlinien für Barrierefreiheit im Web auf <ulink url="http://www.w3.org/TR/WAI-WEBCONTENT/">http://www.w3.org/TR/WAI-WEBCONTENT/</ulink>.</para>
<para>Überprüfen sie, ob in der Dokumentation folgende Informationen enthalten sind:</para>
<itemizedlist>
<listitem>
<para>Notieren Sie, wenn die Anwendung nicht den Standard-Tastaturzugriff des Betriebssystems unterstützt.</para>
</listitem>
<listitem>
<para>Notieren Sie anwendungsspezifische Tastenkombinationen.</para>
</listitem>
<listitem>
<para>Notieren Sie anwendungsspezifische Barrierefreiheit-Funktionen.</para>
</listitem>
<listitem>
<para>Falls eine Aktion für die Maus dokumentiert ist, stellen Sie bitte sicher, dass eine Alternative für die Tastatur bereitsteht.</para>
</listitem>
</itemizedlist>
</section>

<section id="gad-checklist">
<title>Checkliste für Benutzeroberflächen</title>
<para>Dieser Abschnitt fasst die in den <link linkend="gad-ui-guidelines">Richtlinien für Benutzeroberflächen zur Unterstützung der Barrierefreiheit</link> gegebenen Richtlinien zusammen. Sie sollten diesen Abschnitt für weitere Informationen über die Einträge dieser Checkliste zu Rate ziehen.</para>
<para>Beim Testen einer Anwendung auf Barrierefreiheit sollten Sie alle Einträge in dieser Liste abarbeiten. Beachten Sie dabei, ob Ihre Anwendung jeden dieser Tests besteht oder scheitert, oder ob der jeweilige Test auf Ihr Programm nicht anwendbar ist.</para>
<table frame="all" pgwide="1">
<title>Checkliste der allgemeinen Prinzipien</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>GP</entry>
<entry>Allgemeine Prinzipien</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row>
<entry>GP.1</entry>
<entry>Jede Aktion, welche die Benutzerdaten oder Anwendungseinstellungen beeinflusst, kann rückgängig gemacht werden.</entry>
</row>
<row>
<entry>GP.2</entry>
<entry>Alle Anwendungseinstellungen können auf ihre Standardwerte zurückgesetzt werden, ohne dass der Benutzer wissen muss, wie diese Einstellungen aussehen müssen.</entry>
</row>
<row>
<entry>GP.3</entry>
<entry>Nach der Installation kann die Anwendung benutzt werden, ohne dass der Benutzer eine CD oder einen sonstigen Datenträger einlegen muss.</entry>
</row>
<row><entry>GP.4</entry>
<entry>Die am häufigsten benutzten Funktionen befinden sich in der obersten Ebene der Menüstruktur.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste für die Tastaturnavigation</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>KN</entry>
<entry>Tastatursteuerung</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row>
<entry>KN.1</entry>
<entry>Effizienter Tastaturzugriff ist auf alle Funktionsmerkmale der Anwendung möglich.</entry>
</row>
<row>
<entry>KN.2</entry>
<entry>Alle Fenster haben einen logischen Aufbau für die Tastaturnavigation.</entry>
</row>
<row><entry>KN.3</entry>
<entry>Die korrekte Tabulator-Reihenfolge wird für Bedienelemente verwendet, deren Aktivierungsstatus von Ankreuzfeldern, Auswahlknöpfen oder Umschaltknöpfen abhängig ist.</entry>
</row>
<row><entry>KN.4</entry>
<entry>Der Tastaturzugriff auf anwendungsspezifische Funktionen überschreibt keine vorhandenen Barrierefreiheits-Funktionsmerkmale des Systems.</entry>
</row>
<row><entry>KN.5</entry>
<entry>Die Anwendung stellt eine oder mehrere Methoden zur Ausführung von Tastaturaufgaben bereit, wo immer es möglich ist.</entry>
</row>
<row><entry>KN.6</entry>
<entry>Wo immer möglich, gibt es alternative Tastenkombinationen.</entry>
</row>
<row><entry>KN.7</entry>
<entry>Es muss nicht umständlich nach häufig benutzten Tastaturoperationen gesucht werden</entry>
</row>
<row><entry>KN.8</entry>
<entry>Die Anwendung erwartet keine wiederholten, gleichzeitigen Tastendrücke.</entry>
</row>
<row><entry>KN.9</entry>
<entry>Die Anwendung stellt für alle Mausfunktionen entsprechende Bedienungsmöglichkeiten für die Tastatur bereit.</entry>
</row>
<row><entry>KN.10</entry>
<entry>Jedes Objekt, das mit der Maus ausgewählt werden kann, lässt sich auch nur mit der Tastatur auswählen.</entry>
</row>
<row><entry>KN.11</entry>
<entry>Jedes Objekt, das mit der Maus verschoben oder dessen Größe geändert werden kann, lässt sich ebenso auch nur mit der Tastatur verschieben oder dessen Größe ändern.</entry>
</row>
<row><entry>KN.12</entry>
<entry>Die Anwendung nutzt keine generellen Navigationsfunktionen oder Auslöseroperationen.</entry>
</row>
<row><entry>KN.13</entry>
<entry>Alle tastaturbezogenen Menüs, Fenster und Minihilfen erscheinen nahe des Objekts, auf welches sie sich beziehen.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste zur Maus-Interaktion</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>MI</entry>
<entry>Maus-Interaktion</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row><entry>MI.1</entry>
<entry>Keine Operation ist abhängig von der Bedienung der <mousebutton>rechten</mousebutton> oder <mousebutton>mittleren</mousebutton> Maustaste.</entry>
</row>
<row><entry>MI.2</entry>
<entry>Alle Mausaktionen können abgebrochen werden, bevor sie abgeschlossen werden.</entry>
</row>
<row><entry>MI.3</entry>
<entry>Bei Zieh- und Ablegevorgängen wird visuelle Rückmeldung bereitgestellt</entry>
</row>
<row><entry>MI.4</entry>
<entry>Der Mauszeiger gerät nie unter unmittelbare Kontrolle der Anwendung und seine Bewegungsfreiheit wird nie auf den Bildschirmbereich der Anwendung beschränkt.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste für grafische Elemente</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>GE</entry>
<entry>Grafische Elemente</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row><entry>GE.1</entry>
<entry>Es gibt keine fest kodierten grafischen Attribute wie Linien-, Rand- oder Schattendicke.</entry>
</row>
<row><entry>GE.2</entry>
<entry>Alle mehrfarbigen grafischen Elemente können auch nach Möglichkeit monochrom dargestellt werden.</entry>
</row>
<row><entry>GE.3</entry>
<entry>Alle interaktiven Elemente der grafischen Oberfläche sind eindeutig von statischen Elementen unterscheidbar.</entry>
</row>
<row><entry>GE.4</entry>
<entry>Eine Option zum Verbergen eher unwichtiger grafischer Elemente wird bereitgestellt.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste für Schriften und Text</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>FT</entry>
<entry>Schriften und Text</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row><entry>FT.1</entry>
<entry>Schriftstile und -größen sind nicht fest kodiert.</entry>
</row>
<row><entry>FT.2</entry>
<entry>Eine Option zum Abschalten grafischer Texthintergründe steht zur Verfügung.</entry>
</row>
<row><entry>FT.3</entry>
<entry>Alle Bezeichnungen ergeben auch außerhalb des Kontextes einen Sinn.</entry>
</row>
<row><entry>FT.4</entry>
<entry>Beschriftungen werden innerhalb eines Fensters nicht mehrfach verwendet.</entry>
</row>
<row><entry>FT.5</entry>
<entry>Die Positionierung von Beschriftungen ist innerhalb der Anwendung konsistent.</entry>
</row>
<row><entry>FT.6</entry>
<entry>Alle statischen Textbeschriftungen, die andere Bedienelemente bezeichnen, enden mit einem Doppelpunkt.</entry>
</row>
<row><entry>FT.7</entry>
<entry>Statische Textbeschriftungen, die andere Bedienelemente bezeichnen, stehen unmittelbar vor diesen Elementen in der Anordnung.</entry>
</row>
<row><entry>FT.8</entry>
<entry>Eine Alternative zu »WYSIWIG« steht zur Verfügung. Dies wäre zum Beispiel die Festlegung verschiedener Schriften für Bildschirm und Drucker in einem Texteditor.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste für Farben und Kontrast</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>CC</entry>
<entry>Farbe und Kontrast</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row><entry>CC.1</entry>
<entry>Anwendungsfarben sind nicht fest kodiert, sondern werden entweder vom aktuellen Desktop-Thema oder von der Anwendungseinstellung gezeichnet.</entry>
</row>
<row><entry>CC.2</entry>
<entry>Farben werden lediglich als Erweiterung der Darstellung verwendet und nicht als einzige Möglichkeit für die Darstellung von Informationen oder Aktionen.</entry>
</row>
<row>
<entry>CC.3</entry>
<entry>Die Anwendung unterstützt alle Themen und Einstellungen mit hohem Kontrast.</entry>
</row>
<row><entry>CC.4</entry>
<entry>Die Software ist nicht von einem bestimmten Thema mit hohem Kontrast abhängig.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste zur Vergrößerung</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>MG</entry>
<entry>Vergrößerung</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row><entry>MG.1</entry>
<entry>Die Anwendung verfügt über eine Funktion zur Vergrößerung des Arbeitsbereiches.</entry>
</row>
<row><entry>MG.2</entry>
<entry>Die Anwendung stellt eine Option zur Skalierung des Arbeitsbereiches zur Verfügung.</entry>
</row>
<row><entry>MG.3</entry>
<entry>Die Funktionalität der Anwendung wird durch Vergrößerung oder Skalierung nicht beeinträchtigt.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste zu Klängen</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>AU</entry>
<entry>Klänge</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row><entry>AU.1</entry>
<entry>Klänge werden nicht als einzige Möglichkeit für die Darstellung von Informationen oder Aktionen verwendet.</entry>
</row>
<row><entry>AU.2</entry>
<entry>Der Benutzer kann die Frequenz und die Lautstärke aller Klänge und Warntöne einstellen.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste zu Animationen</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>AN</entry>
<entry>Animation</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row><entry>AN.1</entry>
<entry>Es gibt keine blitzenden oder blinkenden Elemente mit einer Frequenz zwischen 2 Hz und 55 Hz.</entry>
</row>
<row><entry>AN.2</entry>
<entry>Jedes Blitzen oder Blinken ist auf kleine Bereiche des Bildschirms beschränkt.</entry>
</row>
<row><entry>AN.3</entry>
<entry>Falls Animation verwendet wird, dann ist eine Option zum Abschalten verfügbar, bereits bevor die Animation erstmals benutzt wird.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste für den Tastaturfokus</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>KF</entry>
<entry>Tastaturfokus</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row><entry>KF.1</entry>
<entry>Wenn ein Fenster geöffnet wird, dann liegt der Fokus zunächst auf dem am häufigsten benutzten Bedienelement.</entry>
</row>
<row><entry>KF.2</entry>
<entry>Die aktuelle Position des Fokus wird jederzeit klar und deutlich dargestellt.</entry>
</row>
<row><entry>KF.3</entry>
<entry>Der Eingabefokus wird nicht in mehreren Fenstern gleichzeitig angezeigt.</entry>
</row>
<row><entry>KF.4</entry>
<entry>Es werden geeignete akustische oder visuelle Rückmeldungen bereitgestellt, wenn der Benutzer versucht, an das Ende oder den Anfang einer Gruppe aufeinander bezogener Elemente zu navigieren.</entry>
</row>
<row><entry>KF.5</entry>
<entry>Das Standardsignal für akustische oder visuelle Warnungen wird abgespielt, wenn der Benutzer eine im jeweiligen Fall nicht anwendbare Taste drückt.</entry>
</row>
<row><entry>KF.6</entry>
<entry>Es gibt genügend Audio-Informationen für den visuellen Fokus, über die dem Benutzer mitgeteilt werden kann, was als Nächstes zu tun ist.</entry>
</row>
<row><entry>KF.7</entry>
<entry>Bei der Nutzung von Hilfstechnologien, wie einem Bildschirmleser oder einer Braille-Zeile, ermittelt das Programm die Position und den Inhalt des visuellen Fokus-Indikators.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste zu Zeitabläufen</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>TM</entry>
<entry>Zeitabläufe</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row><entry>TM.1</entry>
<entry>Es gibt keine fest kodierten Zeitüberschreitungen oder sonstigen zeitbasierten Funktionsmerkmale in der Anwendung.</entry>
</row>
<row><entry>TM.2</entry>
<entry>Das Anzeigen oder Verbergen wichtiger Informationen wird durch die Bewegungen des Mauszeigers nicht beeinflusst.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Checkliste zur Dokumentation</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>DC</entry>
<entry>Dokumentation</entry>
<entry>Bestanden/Durchgefallen/KA</entry>
</row>
</thead>
<tbody>
<row><entry>DC.1</entry>
<entry>Jegliche Dokumentation liegt in einem barrierefreien Format vor, mit einer alternativen Beschreibung in Textform für alle Abbildungen und Diagramme.</entry>
</row>
<row><entry>DC.2</entry>
<entry>Die Dokumentation enthält einen Abschnitt, in dem die Barrierefreiheits-Funktionsmerkmale der Anwendung beschrieben werden.</entry>
</row>
</tbody>
</tgroup>
</table>
</section>

<section>
<title>GOK (GNOME-Bildschirmtastatur)</title>
<note>
<para>Die Informationen auf dieser Seite sind teilweise überholt: GNOME 3 stellt mit <application><ulink url="http://wiki.gnome.org/Caribou">Caribou</ulink></application> einen Ersatz für <application>gok</application> in GNOME 2 bereit.</para>
</note>

<para>Ihre Anwendung sollte mit <application>gok</application> verwendet werden können; Tastatureingaben sollten vollständig von <application>gok</application> erzeugt werden anstatt von der Tastatur. Ziel dabei ist, generell mit Ihrer Anwendung und der Arbeitsumgebung umzugehen und dabei sicherzustellen, dass jegliche Zeicheneingabe mit der Bildschirmtastatur durchgeführt werden kann.</para>
<para><application>gok</application> wird automatisch mit der GNOME-Arbeitsumgebung installiert und sollte daher bereits zur Verfügung stehen. Die vollständige Dokumentation finden Sie auf der <ulink url="http://www.gok.ca">offiziellen go-Seite</ulink>.</para>
<para>Führen Sie die folgenden Schritte aus, um sicherzugehen, dass <application>gok</application> korrekt mit Ihrer Anwendung umgeht:</para>
<procedure>
<step>
<para>Melden Sie sich in der GNOME-Arbeitsumgebung an</para>
</step>
<step>
<para>Starten Sie <application>gok</application></para>
</step>
<step>
<para>Starten Sie Ihre Anwendung</para>
</step>
<step>
<para>Geben Sie etwas in Ihre Anwendung mit einem Zeigegerät (z.B. einer Maus oder Kopf-Tracker) und <application>gok</application> ein.</para>
</step>
<step>
<para>Probieren Sie die Autovervollständigung und die Wortvorhersage-Funktion von <application>gok</application> aus.</para>
</step>
<step>
<para>Verifizieren Sie, dass <application>gok</application> die Knöpfe für <guibutton>Menüs</guibutton> und <guibutton>Werkzeugleisten</guibutton> abhängig von der Art der Anwendung ein- und ausschaltet; die Knöpfe für <guibutton>Menüs</guibutton> und <guibutton>Werkzeugleisten</guibutton> sollten zum Beispiel in der Anwendung »Schriftarten-Eigenschaften« ausgeschaltet, aber in der Anwendung <application>Gedit</application> eingeschaltet sein.</para>
</step>
<step>
<para>Verifizieren Sie, dass Sie mit der <application>gok</application>-Bildschirmtastatur, die über den <guibutton>Compose</guibutton>-Knopf hervorgerufen werden kann, jeglichen Text in die ausgewählte Anwendung einfügen können; starten Sie <application>Gedit</application>, klicken Sie auf das Textfeld und anschließend auf den <guibutton>Compose</guibutton>-Knopf in <application>gok</application>. Klicken Sie auf die benötigten Tasten auf der Bildschirmtastatur. Die Zeichen sollten im <application>Gedit</application>-Textfeld erscheinen.</para>
</step>
<step>
<para>Verifizieren Sie, dass Sie mit dem <guibutton>Launcher</guibutton>-Knopf das <application>Terminal</application>, den <application>Webbrowser</application> oder <application>Texteditor</application> öffnen können.</para>
</step>
<step>
<para>Verifizieren Sie, dass Sie mit dem <guibutton>Activate</guibutton>-Knopf alle momentan laufenden Anwendungen auf dem Schreibtisch ansteuern können, einschließlich der GNOME-Leisten und GNOME-Arbeitsumgebung.</para>
</step>
<step>
<para>Verifizieren Sie, dass Sie mit dem <guibutton>Menus</guibutton>-Knopf alle verfügbaren Menüs in der aktuellen Anwendung auflisten können. Verifizieren Sie, dass durch Klicken auf einen Menüknopf alle Untermenüs und Menüelemente in den Untermenüs angezeigt werden. Verifizieren Sie weiterhin, dass durch Klicken auf ein Menüelement dieses aktiviert wird. Klicken Sie zum Beispiel auf die <application>Hilfebrowser</application>-Anwendung und anschließend auf den <guibutton>Menüs</guibutton>-Knopf. Das <application>gok</application>-Fenster sollte nun die Knöpfe <guibutton>Datei</guibutton>, <guibutton>Gehe zu</guibutton> und <guibutton>Hilfe</guibutton> anzeigen (also die Menüs von <application>Hilfebrowser</application>). Klicken Sie auf <guibutton>Datei</guibutton>. Es sollten nun die Menüelemente <guibutton>Neues Fenster</guibutton> und <guibutton>Fenster schließen</guibutton> angezeigt werden.</para>
</step>
<step>
<para>Verifizieren Sie, dass Sie mit dem <guibutton>Werkzeugleisten</guibutton>-Knopf alle verfügbaren Knöpfe in der Werkzeugleiste der Anwendung auflisten können. Klicken Sie zum Beispiel auf die Anwendung <application>Hilfebrowser</application> und anschließend auf den Knopf <guibutton>Werkzeugleisten</guibutton>. Das <application>gok</application>-Fenster sollte nun die Knöpfe <guibutton>Zurück</guibutton>, <guibutton>Nächste</guibutton> und <guibutton>Home</guibutton> anzeigen.</para>
</step>
<step>
<para>Verifizieren Sie, dass Sie mit dem <guibutton>UI Grab</guibutton>-Knopf alle Knöpfe im ausgewählten Anwendungsfenster anzeigen lassen können. Öffnen Sie zum Beispiel die Anwendung »Schriftarten-Eigenschaften« und klicken Sie auf <guibutton>UI Grab</guibutton> im <application>gok</application>-Fenster. Das <application>gok</application>-Fenster sollte nun die Namen der Knöpfe in der Anwendung anzeigen: <guibutton>Serifen</guibutton>, <guibutton>Serifenlos</guibutton>, <guibutton>Schließen</guibutton> und <guibutton>Hilfe</guibutton>.</para>
</step>
</procedure>
</section>

<section>
<title>Accerciser</title>
<screenshot>
<mediaobject><imageobject> <imagedata fileref="figures/at-arch.png" format="PNG"/> </imageobject> <textobject> <phrase> Accerciser und die GNOME-Barrierefreiheits-Architektur </phrase> </textobject></mediaobject>
</screenshot>

<para><application>Accerciser</application> ist ein in Python geschriebenes Programm zur Untersuchung der Barrierefreiheit für die GNOME-Arbeitsumgebung. Es benutzt AT-SPI zum Inspizieren und Steuern von Widgets. So können Sie überprüfen, ob eine Anwendung korrekte Informationen für Hilfstechnologie und automatisierte Testumgebungen bereitstellt. <application>Accerciser</application> verfügt über eine einfache Plugin-Schnittstelle, die Sie zur Erstellung eigener Ansichten auf Barrierefreiheitsinformationen nutzen können. Die vollständige Dokumentation finden Sie im <ulink url="http://library.gnome.org/devel/accerciser/stable">offiziellen Accerciser-Handbuch</ulink>. Für eine Demonstration von <application>Accerciser</application> und <application>PyATSPI</application> (Python-Schnittstelle für den Zugriff auf und Verwendung von AT-SPI) lesen Sie bitte <ulink url="http://live.gnome.org/Accessibility/PythonPoweredAccessibility">diesen Artikel</ulink>. Eine exzellente Beschreibung vom Autor selbst finden Sie im Artikel <ulink url="http://www.linuxjournal.com/article/9991">Make Your Application Accessible with Accerciser</ulink>.</para>
<note>
<para><application>Accerciser</application> ist ein effektiver Ersatz für das ältere <application>at-poke</application>-Werkzeug.</para>
</note>
</section>

</chapter>

</book>
