]>

<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>

      <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>

  </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>The Accessibility Toolkit (ATK) beschreibt eine Sammlung von Schnittstellen, die von GUI Komponenten implementiert werden müssen, um sie barrierefrei zu gestalten. Die Schnittstellen sind unabhängig vom Toolkit- - Implementierungen können für beliebige Widgets geschrieben sein, u.a. GTK, Motif und Qt.</para>

<para>Die Implementierungen für die GTK-Widgets befinden sich im GAIL-Modul (GNOME Accessibility Implementation Library), das man mit jeder GTK-Anwendung zur Laufzeit dynamisch laden kann. Einmal geladen, besitzen diese Programmteile, die Standard-GTK-Widgets benutzen, grundlegende Barrierefreiheit, ohne die Notwendigkeit, die Anwendung überhaupt verändern zu müssen. Wenn GAIL nicht geladen ist, werden GTK-Widgets eine standardmäßige Implementierung der Zugänglichkeit beinhalten, die im Wesentlichen keine Informationen zurück gibt, allerdings hält es sich nominell an die ATK API. Anwendungen, die Bonobo-Steuerungen benutzen, im Besonderen out-of-process, laden ebenso Code mit Unterstützung für Barrierefreiheit aus dem Modul libgail-gnome. Ob die Anwendungen in der GNOME-Arbeitsumgebung automatisch diese Barrierefreiheit-Supportbibliotheken laden, hängt vom Wert des <application>gconf</application>-Schlüssels »desktop/gnome/interface/accessibility« ab; der boolesche Wert »true« schaltet den Support für unterstützende Technologien ein und Anwendungen, die gnome_program_init aufrufen, werden automatisch die richtigen Barrierefreiheitsbibliotheken zur Laufzeit laden. »Reine GTK+ Anwendungen«, z.B. solche, die GTK+ verwenden, aber nicht nach libgnomme linken, verlassen sich auf den Wert der GTK_MODULES-Umgebungsvariable, die auf den Wert »gail:atk-bridge« gesetzt werden muss, um Hilfstechnologien zu ermöglichen.</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 schnüffelnden 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 für 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 Accessibility 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 Barrierefreihei 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>Die GNOME Barrierefreiheits-Architektur</title>

<mediaobject><imageobject> <imagedata fileref="figures/GNOME_desktop_Accessibility.png" format="PNG"/> </imageobject> <textobject> <phrase>Diagramm der Architektur für Zugangshilfen unter GNOME</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 GNOME-Repertoire-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 verwendete ATK-Oberfläche seiner Rolle in der Benutzeroberfläche umsetzt. 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>

Though GNOME's built-in accessibility support provides significant functionality without any accessibility-specific code changes on the part of the application, applications can often improve on the default descriptions provided for some of the widgets, and tailor them to that widget's specific purpose in your application, via straightforward calls to ATK methods in the application. For instance, in most cases applications should add or change the textual descriptions for these widgets with the appropriate ATK function call, so that an assistive technology can describe their purpose or state to the user. See <link linkend="gad-coding-guidelines">Coding Guidelines for Supporting Accessibility</link> for more information.

</para>

<para>Wenn Ihr Programm angepasste 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>

For additional, in-depth information regarding GTK/GTK+, see the <ulink url="http://library.gnome.org/devel/gtk">GTK+ Reference Manual</ulink>, <ulink url="http://live.gnome.org/GAP/AtkGuide/Gtk">the GTK section of the ATK Guide</ulink>, the GNOME-hosted <ulink url="http://library.gnome.org/devel/gtk-tutorial/stable/">GTK+ 2.0 Tutorial</ulink> and the official <ulink url="http://library.gnome.org/devel/gtk-faq/stable/">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>

To start right in, see <link linkend="gad-overview">Making a GNOME Application Accessible - Overview</link>. For a pre-coding perspective, see <link linkend="gad-ui-guidelines">User Interface Guidelines for Supporting Accessibility</link> or <link linkend="gad-coding-guidelines">Coding Guidelines for Supporting Accessibility</link>. For a checklist of post-design test items, see <link linkend="gad-checklist">User Interface Checklist</link>.

</para>

</section>

<section id="dev-start-2">

<title>Wo lauern die häufigsten Fallen?</title>

<para>Die <link linkend="gad-checklist">Benutzeroberflächen-Checkliste</link> deckt alle Bereiche ab, die manchmal auf der Designbühne ü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>

See <link linkend="gad-custom">Making Custom Components Accessible</link> and <link linkend="gad-api-examples">Examples that Use the Accessibility API</link> for more information.

</para>

</section>

<section id="dev-start-5">

<title>Einführung in ATK, AT-SPI, GAIL 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/4.0/doc/api/org/gnome/atk/package-summary.html">das ATK-SourceForge-Projekt</ulink> und <ulink url="http://library.gnome.org/devel/atk/stable/">die ATK-Bibliothek</ulink> für weitere Informationen.</para>

<para>

AT-SPI is the primary service interface by which assistive technologies query and receive notifications from running applications. The full API can be explored <ulink url="http://library.gnome.org/devel/at-spi-cspi/stable/">here</ulink>. Additional material is available from <ulink url="http://accessibility.kde.org/developer/atk.php#coreclasses">the KDE Accessibility Development Community</ulink>.

</para>

<para>

GAIL (GNOME Accessibility Implementation Library) is an implementation of the accessibility interfaces defined by ATK. GTK is a toolkit which is already mapped to ATK by the GAIL module. License, download and other information can be found <ulink url="http://www.t2-project.org/packages/gail.html">here</ulink>. The <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">GAIL source code</ulink> also serves as an excellent tutorial for advanced ATK usage. In addition, you may be interested in the <ulink url="http://library.gnome.org/devel/gail-libgail-util/stable/">GAIL Reference Manual</ulink>.

</para>

<para>

GTK+ is a library for creating graphical user interfaces. It works on many UNIX-like platforms, Windows, and on framebuffer devices. GTK+ is released under the GNU Library General Public License (GNU LGPL), which allows for flexible licensing of client applications. GTK+ has a C-based object-oriented architecture that allows for maximum flexibility. Bindings for other languages have been written, including C++, Objective-C, Guile/Scheme, Perl, Python, TOM, Ada95, Free Pascal, and Eiffel.

</para>

<para>

For additional, in-depth information regarding GTK/GTK+, see the <ulink url="http://library.gnome.org/devel/gtk">GTK+ Reference Manual</ulink>, <ulink url="http://wiki.gnome.org/Accessibility/Documentation/GNOME2/AtkGuide/Gtk">the GTK section of the ATK Guide</ulink>, the GNOME-hosted <ulink url="http://library.gnome.org/devel/gtk-tutorial/stable/">GTK+ 2.0 Tutorial</ulink> and the official <ulink url="http://library.gnome.org/devel/gtk-faq/stable/">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. Aber Sie sollten nach Objekten in Ihrem 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 angepasste Widgets verwendet, sollten Sie etwas dafür tun, diese Widget-Eigenschaften den Hilfstechnologien nutzbar 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 einsetzen</link> für weitere Informationen. Zusätzlich können detaillierte Informationen in Marc Mulcahys 2002 GUADEC-Präsentation gefunden werden, <ulink url="https://projects.gnome.org/accessibility/talks/GUAD3C/making-apps-accessible/start.html">"GNOME-Programme barrierefrei machen".</ulink></para>

</section>

<section id="gad-coding-guidelines">

<title>Code-Richtlinien zur Unterstützung der Barrierefreiheit</title>

<para>

Here are some things you can do in your code to make your program work as well as possible with assistive technologies. (You can find a list of things to consider when designing your GUI in the <link linkend="gad-ui-guidelines">User Interface Guidelines for Supporting Accessibility</link> section later in this document):

</para>

<itemizedlist>

<listitem>

<para>

For components that don't display a short string (such as a graphical button), specify a name for it with <function>atk_object_set_name()</function>. You might want to do this for image-only buttons, panels that provide logical groupings, text areas, and so on.

</para>

</listitem>

<listitem>

<para>

If you can't provide a tooltip for a component, use <function>atk_object_set_description()</function> instead to provide a description that assistive technologies can give the user. For example, to provide an accessible description for a <guibutton>Close</guibutton> button:

</para>

<example>

<title>Bereitstellung einer Accessible-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>

Whenever you have a label that describes another component, use <function>atk_relation_set_add_relation()</function> so that assistive technologies can find the component with which the label is associated. (If you associate the label with the component using <function>gtk_label_set_mnemonic_widget()</function>, the <constant>ATK_RELATION_LABEL_FOR</constant> relation is generated automatically, so the following code would not be necessary):

</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>

Don't break what you get for free! If your GUI has an inaccessible container, any components inside that container may become inaccessible.

</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 Accessible-Widgets erstellen können.</para>

<title>Häufig genutzte API-Aufrufe von ATK</title>

<tgroup cols="2" align="left">

<row>

<entry>API</entry>

<entry>Beschreibung</entry>

</row>

<row>

<entry>

<para><function>AtkObject* gtk_widget_get_accessible (GtkWidget*)</function></para>

</entry>

<entry>

<para>Gibt das Accessible-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 Accessible-Objekts fest. Wenn beispielsweise das Objekt ein grafischer Knopf ist, der beim Anklicken die Anwendung beeendet, 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 Accessble-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 Accessible-Bildobjekt fest. Wenn das Objekzt 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>

</tgroup>

</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>

The examples in the rest of this section are mostly to give you a flavor of the scope of the ATK. They cover techniques that you may never need to use as an application developer, although they may be of interest if you are writing your own custom widgets (see <link linkend="gad-custom">Making Custom Components Accessible</link>) or if you want to write an assistive technology application. Whatever the purpose, the <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">GAIL source code</ulink> serves as an excellent tutorial for advanced ATK usage. Please note that since GTK+ 3.1.10, Gail has been merged into GTK+ and is no longer a module on its own.

</para>

<section>

<title>GTK-Module</title>

<para>

Programs that make use of GAIL (the accessibility implementation library for GTK widgets) are written as GTK modules. GTK modules are loaded into the program space if the <varname>GTK_MODULES</varname> environment variable specifies the module library name(s). If there are multiple module libraries, separate them with colons. For example:

</para>

<para><userinput>setenv GTK_MODULES "libgail:libtestprops"</userinput></para>

<para>Alle GTK-Module haben eine <function>gtk_module_init()</function>-Funktion.</para>

</section>

<section>

<title>Zugänglichkeitsinformationen einer Anwendung sammeln</title>

<para>

A program that wishes to make use of ATK calls would likely need to do one (or more) of the following things:

</para>

<orderedlist>

<listitem>

<para>

Create an event watcher, for example with the <function>atk_add_focus_tracker()</function> 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>Richte einen globalen Ereignislistener ein, 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>

where <function>_my_global_listener</function> has the prototype of a Glib <type>GSignalEmissionHook</type>. This example would cause the <function>_my_global_listener()</function> to be called whenever an enter_notify_even signal occurs on a <type>GtkWidget</type> object.

</para>

</listitem>

<listitem>

<para>

Access the ATK top-level object with the following function call.

</para>

<programlisting>AtkObject *root_obj = atk_get_root();</programlisting>

<para>

This returns an <type>AtkObject</type> which contains all toplevel windows in the currently running program. The user could then navigate through the object hierarchy by accessing the root object's children, which corresponds to the toplevel windows.

</para>

</listitem>

</orderedlist>

</section>

<section>

<title>Querying an <type>AtkObject</type>'s Interfaces</title>

<para>

Having located the <type>AtkObject</type> associated with an object in the application (e.g. by using <function>gtk_widget_get_accessible()</function>), you can find out what interfaces it implements in various ways:

</para>

<orderedlist>

<listitem>

<para>

Use the supplied <function>ATK_IS_...</function> macros, for example:

</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 jede Schnittstelle)</para>

</listitem>

</itemizedlist>

<para>

If the macro returns <function>TRUE</function>, the interface calls can safely be made on that ATK object.

</para>

</listitem>

<listitem>

<para>

Test the role of the <type>AtkObject</type> by calling <function>atk_object_get_role()</function>. Any given role implements a specific number of ATK APIs.

</para>

</listitem>

</orderedlist>

</section>

<section>

<title>Einen ATK Nachrichtenhandler einrichten</title>

<para>

Using the <constant>column_inserted</constant> signal as an example:

</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>This will cause <function>_my_table_column_inserted_func()</function> to be called whenever a column_inserted signal is emitted on the <type>AtkObject</type> <varname>my_atk_object</varname>.

</para>

<para>

Connecting to a signal is slightly different if the signal supports detail. The <constant>children_changed</constant> signal supports the <parameter>add</parameter> detail. To connect to a signal when the <parameter>add</parameter> detail is also specified, this technique is used:

</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>

This will cause <function>_my_children_changed_func()</function> to be called whenever a <constant>children_changed</constant> signal with the <parameter>add</parameter> detail is emitted on the <type>AtkObject</type> <varname>my_atk_obj</varname>.

</para>

</section>

<section>

<title>Implementieren eines ATK-Objekts</title>

<para>

You will need to implement your own ATK objects for any widgets that do not already have an accessible implementation in GAIL (or the equivalent library for other widget sets).  This should be implemented as a GTK module, which, as before, should be included in the <envar>GTK_MODULES</envar> environment variable so it is loaded at runtime.

</para>

<section>

<title>Registry</title>

<para>

For this example we will assume there is an object called GTK_TYPE_MYTYPE. The ATK implementation will be called <type>MYATKIMP_TYPE_MYTYPE</type>. A factory will be needed which will be called <type>MYATKIMP_TYPE_MYTYPE_FACTORY</type>.

</para>

<para>

To register an ATK implementation of a GTK object, these steps must be followed in the module's <function>gtk_module_init()</function> function:

</para>

<orderedlist>

<listitem>

<para>

Access the default registry:

</para>

<programlisting>

default_registry = atk_get_default_registry();

</programlisting>

</listitem>

<listitem><para>Register the ATK object in the <function>gtk_module_init()</function> function of this module by making this function call:

</para>

<programlisting>

atk_registry_set_factory_type (default_registry, GTK_TYPE_MYTYPE, 

MYATKIMP_TYPE_MYTYPE_FACTORY); 

</programlisting>

</listitem>

</orderedlist>

<para>

This will register the AtkObject implementation of <type>GTK_TYPE_MYTYPE</type> to <type>MYATKIMP_TYPE_MYTYPE_FACTORY</type>. This factory will be implemented so that it knows how to build objects of type <type>MYATKIMP_TYPE_MYTYPE</type>.

</para>

</section>

<section>

<title>Factory</title>

<para>

The factory must be implemented as a child of class type <type>ATK_TYPE_OBJECT_FACTORY</type> and must implement the function <function>create_accessible()</function>. This function must create an appropriate <type>AtkObject</type>. A factory can be used to create more than one type of object, in which case its <function>create_accessible()</function> function will need to be smart enough to build and return the correct <type>AtkObject</type>.

</para>

</section>

<section>

<title>ATK-Implementierung für ein bestimmtes Objekt</title>

<para>

All <type>GObject</type>s implement a <function>get_type()</function> function.  Using the above example the naming convention for this function name would be <function>myatkimp_mytype_get_type()</function>.

</para>

<para>

In this function, you specify which interfaces your object implements. If the following logic were included in this <function>get_type()</function> function, this object would implement the <type>ATK_TEXT</type> interface:

</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, 

                             &atk_text_info); 

</programlisting>

</example>

<para>

The function <function>atk_text_interface_init()</function>, which has the following prototype, would need to be implemented:

</para>

<programlisting>

void atk_text_interface_init (AtkTextIface *iface); 

</programlisting>

<para>

This function would connect the interface function calls to the specific implementation as follows:

</para>

<example>

<title>Connecting custom interface calls to an AtkObject implementation</title>

<programlisting>

void 

atk_text_interface_init (AtkTextIface *iface) 

{ 

   g_return_if_fail (iface != NULL); 

   iface->get_text = myatkimp_mytype_get_text; 

   iface->get_character_at_offset = myatkimp_mytype_get_character_at_offset; 

   ... 

}

</programlisting>

</example>

<para>

Then the functions <function>myatkimp_mytype_get_text()</function>, <function>myatkimp_mytype_get_character_at_offset()</function>, and the rest of the <type>ATK_TEXT</type> interface functions would need to be implemented.

</para>

</section>

<section>

<title><type>AtkObject</type>-Implementierung</title>

<para>

<type>AtkObject</type>s are <type>GObjects</type>, and all <type>GObject</type>s need to specify the <function>get_type()</function> function. Here is an example that sets up a class and instance initializer. This <function>get_type()</function> function also specifies that the object implements <type>ATK_TEXT</type> and specifies the parent object to be <type>MYATKIMP_MYPARENTTYPE</type>.

</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", &tinfo, 0); 

      /* This class implements interface ATK_TYPE_TEXT */ 

      g_type_add_interface_static (type, ATK_TYPE_TEXT, 

                                   &atk_text_info); 

   } 

   return type; 

} 

</programlisting>

</example>

</section>

<section>

<title>Initialisierung von Klassen und Instanzen</title>

<para>

You will have to set up a class initializer for the <type>GObject</type> if your <type>AtkObject</type> implementation either:

</para>

<orderedlist>

<listitem>

<para>

Redefines any function calls defined by the object's parent. This is typically necessary when an object needs to implement a function like <function>atk_object_get_n_accessible_children()</function>.  This is necessary if the object has children, but they are not represented with widgets.

</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>Benötigt eine <function>parent->init</function>-, <function>parent->notify_gtk</function>- oder <function>parent->finalize</function>-Funktion. Dieses Beispiel definiert alle drei:</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->init</para>

<para>

A <function>parent->init()</function> function may be necessary if the ATK implementation needs to do either of the following:

</para> 

<orderedlist>

<listitem>

<para>

Cache any data obtained from a backing GTK widget.

</para>

</listitem>

<listitem>

<para>

Listen to any signals from the backing GTK widget.

</para>

</listitem>

</orderedlist>

<para>Hier ein Beispiel für beides:</para>

<example>

<title>Eine benutzerdefinierte <function>init()</function>-Funktion</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->notify_gtk</para>

<para>

If the ATK implementation needs to listen to any property notifications on the backing GTK object, a <function>parent->notify_gtk()</function> function may be necessary. For example:

</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->name, "property-of-interest") == 0) 

   { 

      /* Handle the property change. */ 

   } 

   else 

   { 

      parent_class->notify_gtk (obj, pspec); 

   } 

} 

</programlisting>

</example>

</listitem>

<listitem>

<para>parent->finalize</para>

<para>

If it is necessary to free any data when a <type>GObject</type> instance is destroyed, then a <function>finalize()</function> function is needed to free the memory.  For example:

</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->cached_value); 

   G_OBJECT_CLASS (parent_class)->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>

assess a custom widget according to the applicable <link linkend="gad-ui-guidelines">User Interface Guidelines</link>;

</para>

</listitem>

<listitem>

<para>

determine which <ulink url="https://developer.gnome.org/atk/stable/interfaces.html">ATK interfaces</ulink> a custom widget should implement, according to the widget's feature set and function;

</para>

</listitem>

<listitem>

<para>

assess which <ulink url="https://developer.gnome.org/atk/stable/interfaces.html">ATK interfaces</ulink> can be inherited from the parent widget class;

</para>

</listitem>

<listitem>

<para>

implement the appropriate ATK interfaces for the widget class in one of two ways:

</para>

<itemizedlist>

<listitem>

<para>

directly by the custom widget, or

</para>

</listitem>

<listitem>

<para>

in an <ulink url="http://library.gnome.org/devel/atk/stable/AtkObject.html"><type>AtkObject</type></ulink> subtype created by a new <ulink url="http://library.gnome.org/devel/atk/stable/AtkObjectFactory.html"><type>AtkObjectFactory</type></ulink> subclass

</para>

</listitem>

</itemizedlist>

<para>

If the second method is used, the appropriate factory type must be registered with the <type>AtkObjectFactoryRegistry</type> at runtime.

</para>

</listitem>

</itemizedlist>

<para>

The <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">GAIL source code</ulink> serves as an excellent tutorial for advanced ATK usage. 

</para>

</section>

<section id="gad-ui-guidelines">

<title>Richtlinien für Benutzeroberflächen zur Unterstützung der Barrierefreiheit</title>

<para>

When designing your application's GUI, there are a number of simple guidelines you should follow to ensure that it can be used by as wide an audience as possible, whether in conjunction with assistive technologies or not. Don't be fooled into thinking that this is just a case of "making your GUI usable by people with disabilities", though, and that you shouldn't bother if you know a disabled person is never going to use your application. Following these guidelines will improve the overall usability of your application for everyone who uses it - including you!

</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 Form dieser Fehler haben, werden sowohl der Aufwand als auch die verschwendete Zeit manchmal sehr hoch sein. Diesen 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 Ebenen 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 zufällig 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 Körperbehinderungen 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>

Most functionality should be easy to make accessible by using keyboard mnemonics and accelerators, and the toolkit's built-in navigation features. However, operations that rely on drag-and-drop, for example, may require more thought.

</para>

<itemizedlist>

<listitem>

<para>

Provide efficient keyboard access to all application features. Some users may be unable to use a mouse, and many "power-users" prefer to use the keyboard anyway. Also, some specialized assistive technology input devices may simulate keyboard events rather than mouse events. Since typing is difficult or even painful for some users, it is important to provide a keyboard interface that minimizes the number of keystrokes required for any given task.

</para>

</listitem>

<listitem>

<para>

Use a logical keyboard navigation order. When navigating around a window with the <keycap>Tab</keycap> key, keyboard focus should move between controls in a predictable order.  In Western locales, this is normally left to right and top to bottom.

</para>

</listitem>

<listitem>

<para>

Ensure correct tab order for controls whose enabled state is dependent on checkbox, radio button or toggle button state. When such a button is selected, all its dependent controls should be enabled, and all the dependent controls of any other button in the group should be disabled. When the user selects a checkbox, radio button or toggle button that has dependent controls, do not automatically give focus to the first dependent control, but instead leave the focus on the button.

</para>

</listitem>

<listitem>

<para>

Don't override existing system-level accessibility features. For example, <ulink url="http://www.rehab.uiuc.edu/accessx/overview.html">AccessX</ulink> is an Xserver extension that has been supported since X11R6. The MouseKeys feature of this extension allows mouse movement and button clicks to be simulated using the keypad. Therefore you should not add features to your application that can only be accessed by pressing keys on the keypad, as users relying on the MouseKeys feature will not be able to use them.

</para>

</listitem>

<listitem>

<para>

Provide more than one method to perform keyboard tasks where possible. Some users may find some keys and key combinations easier to use than others.

</para>

</listitem>

<listitem>

<para>

Provide both keyboard and mouse access to functions where possible. Some users may only be able to use either the mouse or the keyboard, but not both.

</para>

</listitem>

<listitem>

<para>

Don't assign awkward reaches to frequently performed keyboard operations. Some people may only be able to use one hand on the keyboard, so shortcuts that can be easily used with one hand are preferable for common operations. In any case, having to frequently perform long or difficult reaches on the keyboard can increase muscle strain for all users, increasing the risk of pain or injury.