# Guía de accesibilidad para los desarrolladores de GNOME

## ¿Qué es la accesibilidad?

Accesibilidad significa ayudar a que gente con discapacidades participe en las actividades sustanciales de la vida. Esto incluye trabajo, el uso de servicios, productos e información. GNOME incluye bibliotecas y soporte para entorno de trabajo que permite que personas con discapacidades utilicen toda la funcionalidad del entorno de usuario de GNOME.

Junto con las tecnologías de asistencia si es necesario (interfaces de voz, pantallas de lector, dispositivos de entrada alternativos, y similares) gente con discapacidades permanentes o temporales puede usar el escritorio y las aplicaciones de GNOME. Las tecnologías de asistencia también son útiles para gente que usa los equipos fuera de su casa u oficina. Por ejemplo, si está en un atasco de tráfico puede utilizar la entrada y salida de voz para comprobar su correo electrónico.

Las tecnologías de asistencia reciben información desde aplicaciones a través del API de las Herramientas de accesibilidad, que puede encontrar en el módulo de atk en el repositorio de GNOME. Debido a que el soporte de accesibilidad API está construido dentro de los widgets de GNOME, su programa GNOME debería funcionar razonablemente bien con las tecnologías de asistencia sin ningún trabajo adicional por su parte. Por ejemplo, las tecnologías de asistencia pueden leer automáticamente las etiquetas de los widgets que generalmente establecerá en su programa (ej. con las llamadas a funciones de GTK tales como `gtk_label_set_text()` o `gtk_button_new_with_label()`). También pueden encontrarse si hay cualquier descripción de texto asociada con un widget, y usarlo para describir el widget al usuario.

Con un poco de esfuerzo adicional puede hacer que su programa funcione aún más suavemente con tecnologías de asistencia. Además de ayudar a usuarios individuales, también hará que su producto sea más atractivo en el mercados del gobierno y educativo, muchos de los cuales ahora requieren que sus aplicaciones sean accesibles por ley.

### Tipos de discapacidades

Sólo en los EE. UU. existe una estimación de 30 000 000 personas cuya capacidad para usar equipos puede estar comprometida por un diseño inaccesible. Globalmente alrededor del 8% de la población que usa Internet tiene algún tipo de discapacidad. Las discapacidades pueden ser de una de estas categorías:

- Discapacidades visuales: estos pueden ir desde baja visión (incluyendo visión borrosa o nublada, visión extrema de hipermetropía o miopía, daltonismo, y visión de túnel, entre otros) hasta la ceguera completa. Una pobre elección del tamaño y color del texto, y tareas que implican una buena coordinación mano-ojo (tales como mover el ratón) pueden causan problemas para estos usuarios.

- Discapacidades de movimiento: los usuarios con un control pobre o debilidad en sus músculos pueden encontrar muy difícil usar un teclado estándar o un ratón. Por ejemplo, pueden ser incapaces de mantener pulsadas dos teclas a la vez, o pueden ser más propensos a pulsar teclas accidentalmente.

- Deficiencias auditivas: éstas pueden variar desde ser capaz de oír algunos sonidos pero no distinguir las palabras habladas, hasta sordera profunda. Las aplicaciones que comunican información importante exclusivamente a través del sonido pueden causar problemas para estos usuarios.

- Trastornos Cognitivos y del Lenguaje - éstas pueden ir desde la dislexia a las dificultades para recordar cosas, resolver problemas o comprender y utilizar el lenguaje hablado o escrito. Es difícil la exposición compleja o inconsistente, o la selección pobre de palabras usando ordenadores para estos usuarios.

- Trastornos convulsivos: cierta luz o patrones de sonido pueden causar ataques epilépticos en algunos usuarios susceptibles.

### Cómo funciona la accesibilidad en GNOME

El Kit de herramientas de accesibilidad (ATK) describe un grupo de interfaces que necesita ser implementado por los componentes IGU para hacerlos accesibles. Los interfaces son conjuntos de herramientas independientes; las implementaciones se pueden escribir para cualquier conjunto de widgets, como GTK, Motif o Qt.

La implementación para los widgets GTK está en un módulo llamado GAIL («GNOME Accessibility Implementation Library», Biblioteca de implementación de accesibilidad de GNOME), cargada dinámicamente, en tiempo de ejecución, por una aplicación GTK. Una vez cargadas, dichas partes de su aplicación que usan widgets estándar GTK tendrán un nivel básico de accesibilidad, sin tener que modificar nada de su aplicación. Si no se carga GAIL, los widgets GTK tendrán una implementación de accesibilidad predeterminada que esencialmente no devuelve ninguna información, aunque nominalmente se ajusta la API de ATK. Las aplicaciones que usan controladores Bonobo, particularmente aquellas fuera del proceso, también cargan códigos para el soporte de accesibilidad desde el módulo libgail-gnome. Que las aplicaciones del escritorio GNOME carguen automáticamente estas bibliotecas de soporte para la accesibilidad depende del valor de una clave de gconf, «/desktop/gnome/interface/accessibility»; un valor booleano cierto activa el soporte para las tecnologías de asistencia y las aplicaciones que llaman a gnome_program_init que cargará automáticamente librerías de accesibilidad en tiempo de carga. Las «aplicaciones GTK puras» por ejemplo, aquellas que usan gtk+ pero no enlazan libgnome, dependen del valor de la variable de entorno GTK_MODULES, las cual debe establecerse a «gail:atk-bridge» para activar el soporte de las tecnologías de asistencia.

La mayoría de las tecnologías de asistencia que funcionan en otros escritorios históricamente han encontrado necesario mantener un modelo complejo fuera de la pantalla de las aplicaciones del escritorio, basada en fisgonear los eventos del S.O., uso de S.O. no soportados y características de la aplicación y API y otras técnicas altamente no portables. Esto ha hecho que el apoyo tecnológico de la ayuda sea un poco frágil y la aplicación específica del S.O., incluso específicos de la aplicación de versiones. Por el contrario, en el escritorio GNOME, toda la información requerida por las TA lo proporcionan las aplicaciones en ejecución, a través del marco de accesibilidad de GNOME, un conjunto de herramientas independientes de la interfaz de proveedor de servicios (SPI). El SPI proporciona medios de TA basados en UNIX, tales como lectores de pantalla y magnificadores de pantalla, para obtener información sobre la accesibilidad de la ejecución de aplicaciones a través de una API consistente y estable, y en muchos casos puede eliminar la necesidad de un modelo fuera de la pantalla. El soporte de accesibilidad para las solicitudes está «incluída» en los kits de herramientas de aplicaciones a través del conjunto del API de herramientas adecuadas (por ejemplo, ATK para la mayoría de las aplicaciones nativas de C y el API de accesibilidad de Java para las aplicaciones Java), y exportados al interfaz común «AT-SPI» a través del correspondiente «bridge» (vea el diagrama abajo).

#### Arquitectura de accesibilidad de GNOME

Diagrama de la arquitectura de accesibilidad de GNOME

El soporte integrado de accesibilidad de GNOME significa que las aplicaciones creadas utilizando los widgets obtienen soporte para ñas tecnologías de asistencia de forma predeterminada, siempre que los widgets no se utilicen de forma inusual utilizan y entre en conflicto con este soporte integrado.

Un widget de GTK+/GNOME es accesible si su uso sigue las directrices de accesibilidad general en otras partes de este documento, e implementa los interfaces de ATK apropiadamente para su rol en el interfaz del usuario. La implementaciones de ATK se proporcionan para el kit de herramientas de los widgets de GNOME llamado «stock» (ej. GTK+ no obsoleto y los widgets de GNOME), y en muchos casos los widgets nuevos que derivan tribialmente desde los widgets de GTK+ y GNOME existentes que también heredarán el soporte adecuado de accesibilidad.

Aunque el soporte integrado de accesibilidad de GNOME proporciona una funcionalidad significativa, sin cambios de código específicos de accesibilidad en la parte de la aplicación, a menudo las aplicaciones puede mejorar sus descripciones predeterminadas que proporcionan algunos de los «widgets», y adaptarlas para algunos de los widgets específicos de su aplicación, a través de llamadas directas a los métodos de ATK en la aplicación. Por ejemplo, en la mayoría de los casos las solicitudes deben añadir o cambiar las descripciones textuales de los widgets con la llamada de función apropiada de ATK, de forma que una tecnología de asistencia puede describir su finalidad o del estado para el usuario. Para obtener más información consulte las Instrucciones de programación para soporte de accesibilidad.

Si su aplicación usa widgets personalizados, puede que tenga que hacer algún trabajo para exponer las propiedades de los widgets para las tecnologías de asistencia. Para obtener más información, consulte Creación de componentes personalizados accesibles y Ejemplos de uso de la API de accesibilidad.

Para obtener información en mayor profundidad acerca de GTK/GTK+, consulte el Manual de referencia de GTK+, la sección de GTK de la Guía de ATK, la organización para GNOME del Tutorial de GTK+ 2.0 y las P+F de GTK+.

### Inicio rápido para desarrolladores

Aquí hay algunos puntos comunes de inicio:

#### ¿Cómo compruebo si mi aplicación es accesible o no?

Para comenzar correctamente, consulte Programación de una aplicación accesible para GNOME - Información general. Para obtener una perspectiva de pre-codificación, consulte la Guía de interfaz de usuario para el soporte de accesibilidad o la Guía de codificación de apoyo de accesibilidad. Para obtener una lista de elementos de prueba de post-diseño consulte la Lista de comprobación de la interfaz de usuario.

#### ¿Cuáles son las principales dificultades?

La lista de comprobación del interfaz de usuario cubre todas las áreas y algunas veces ignoradas en la fase de diseño.

#### ¿Cómo hago cosas ATK comunes?

Una lista abreviada de llamadas a ATK se puede encontrar aquí.

#### ¿Cómo hago cosas ATK complejas?

Para obtener más información consulte Hacer los componentes personalizados accesibles y Ejemplos que usano la API de accesibilidad.

#### Introducción a ATK, AT-SPI, GAIL y GTK+

Arquitectura de accesibilidad de GNOME

ATK es el kit de herramientas que usa GNOME para activar la accesibilidad para usuarios que necesiten un soporte adicional para sacar el mayor rendimiento de sus equipos. ATK lo usan herramientas tales como los lectores de pantalla, magnificadores y dispositivos de entrada para permitir una interacción rica con el escritorio a través de medios alternativos. Para obtener más información, consulte el Proyecto ATK en SourceForge y la biblioteca de ATK.

AT-SPI es el servicio primario de interfaz por el que las tecnologías de asistencia solicitan y reciben notificaciones desde las aplicaciones en ejecución. Puede examinar la API aquí. Existe material adicional disponible en la Comunidad de desarrollo de accesibilidad de KDE.

GAIL («GNOME Accessibility Implementation Library», Biblioteca de implementación de accesibilidad de GNOME) es una implementación de las interfaces de accesibilidad definidas por ATK. GTK es un grupo de herramientas que ya está mapeado para ATK por el módulo de GAIL. Puede encontrar la licencia, la descarga y otra información aquí. El código fuente de GAIL también sirve como un tutorial excelente para el uso avanzado de ATK. Además, puede interesarle el Manual de Referencia de GAIL.

GTK+ es una biblioteca para crear interfaces gráficas de usuario. Funciona en muchas plataformas UNIX, Windows y en dispositivos de framebuffer. GTK + se publica bajo la Licencia General Pública de GNU (GNU LGPL), la cual permite que la concesión flexible de licencias de aplicaciones cliente. GTK+ tiene una arquitectura basada en C orientada a objetos que proporciona una flexibilidad máxima. Se han escrito «bindings» para otros lenguajes, incluyendo C++, Objective-C, Guile/Scheme, Perl, Python, TOM, Ada95, Free Pascal y Eiffel.

Para obtener información en mayor profundidad acerca de GTK/GTK+, consulte el Manual de referencia de GTK+, la sección de GTK de la Guía de ATK, la organización para GNOME del Tutorial de GTK+ 2.0 y las P+F de GTK+.

### Hacer que una aplicación de GNOME sea accesible: Visión general

Si su aplicación sólo usa los widgets estándar de GTK, probablemente tendrá poco o nada que hacer para hacer (razonablemente) accesible su aplicación. Pero cuidado con los objetos de la interfaz gráfica de usuario que no tienen una descripción textual asociada a ellos, tales como botones gráficos o indicadores de estado que no tienen etiquetas o información sobre herramientas.

Probablemente también pueda mejorar las descripciones predeterminadas para algunos de los widgets, y adaptarlos a propósito específico del widget en su aplicación. Podría añadir o cambiar las descripciones textuales para estos widgets con la llamada de función ATK apropiada, de forma que una tecnología de asistencia puede describir su propósito o estado al usuario. Consulte las Guías de codificación para soportar accesibilidad para obtener más información.

Si su aplicación usa widgets personalizados, puede tener que trabajar un poco para exponer las propiedades de los widgets para las tecnologías de asistencia. Consulte Creación de componentes personalizados accesibles y Ejemplos que usan la API de accesibilidad para obtener más información. Puede encontrar información adicional detallada en la presentación de Marc Mulcahy's 2002 GUADEC, Making GNOME Applications Accessible.

### Guías de programación para soporte de accesibilidad

Aquí hay algunas cosas que puede codificar para hacer que su programa trabaje tan bien como sea posible con las tecnologías de asistencia. (Puede encontrar una lista de cosas que tener en cuenta cuando diseñe su IGU en la sección Guías de la interfaz de usuario para soportar accesibilidad más tarde en sus documentos):

- Para los componentes que no muestren una cadena corta (tales como un botón gráfico), especifique un nombre para ellos con `atk_object_set_name()`. Puede querer hacerlo para botones con imagen exclusivamente, paneles que proporcionen agrupaciones lógicas, áreas de texto y demás.

- Si no puede proporcionar una sugerencia para un componente, use `atk_object_set_description()` en su lugar para proporcionar una descripción que las tecnologías de asistencia puedan proporcionar al usuario. Por ejemplo, para proporcionar una descripción accesible para un botón `Cerrar`.

  #### Proporcionar una descripción accesible para un GtkButton

      {
        AtkObject *obj;
        obj = gtk_widget_get_accessible(button);
        atk_object_set_description(obj,_("Cierra la ventana"));
      }

- Use `atk_image_set_description()` para proporcionar una descripción de texto para todas las imágenes e iconos de su programa.

- Si varios componentes forman un grupo lógico, intente ponerlos en un contenedor.

- Cuando tenga una etiqueta que describe otro componente, utilice `atk_relation_set_add_relation()` para que la tecnología de asistencia pueda encontrar el componente con el que la etiqueta está asociada. (Si asocia la etiqueta con el componente usando `gtk_label_set_mnemonic_widget()`, generalmente la relación de `ATK_RELATION_LABEL_FOR` se genera automáticamente, así que el siguiente código podría no ser necesario):

  #### Relacionar un GtkLabel con un GtkWidget

      {
        GtkWidget *widget;
        GtkLabel *label;

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

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

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

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

- Si crea un widget personalizado, asegúrese que soporta accesibilidad. Los componentes personalizados que descienden de otros widgets GTK deben reemplazar la información heredada de accesibilidad según sea necesario. Para obtener más información, consulte la Creación de componentes accesibles personalizados.

- No rompa lo que consigue gratis. Si su IGU tiene un contenedor inaccesible, cualquier componente dentro de ese contenedor puede resultar inaccesible.

### La API de accesibilidad

Aquí hay unas pocas llamadas básicas de la API que puede necesitar usar en sus aplicaciones para asegurarse que funciona bien con la tecnología de asistencia. La API completa de accesibilidad es extensible, para permitirle escribir sus propios widgets personalizados de accesibilidad, por ejemplo.

### Llamadas a la API de ATK comúnmente usadas

API | Descripción
`AtkObject* gtk_widget_get_accessible (GtkWidget*)` | Devuelve a una tecnología accesible el objeto accesible que describe el widget GTK especificado.
`void atk_object_set_name (AtkObject*, const gchar*)` | Establece el nombre del objeto accesible. Por ejemplo, si el objeto es un botón gráfico que sale de la aplicación al pulsarlo, el nombre puede ser «Salir».
`void atk_object_set_description (AtkObject*, const gchar*)` | Establece la descripción textual del objeto accesible. Por ejemplo, si el objeto es un botón gráfico «Cerrar», la descripción puede ser «Cierra la ventana».
`AtkRelation* atk_relation_new (AtkObject**, gint, AtkRelationType)` | Crea una nueva relación entre la clave especificada y la lista especificada de objetos de destino. Generalmente una relación indica a las tecnologías de asistencia que un widget está relacionado, de alguna forma, con otro. Por ejemplo, que un widget GtkLabel en particular es el título de un GtkTreeView en la misma ventana.
`void atk_image_set_description (AtkImage*, const gchar*)` | Establece la descripción textual del objeto de la imagen accesible. Por ejemplo, si el objeto es una miniatura de un escritorio virtual en una miniaplicación del panel, la descripción puede ser «Imagen mostrando la organización de las ventanas en el escritorio 1».

### Ejemplos que usan la API de accesibilidad

Como se indicó anteriormente, podría tener poco o nada de trabajo para hacer su aplicación accesible si usa el conjunto de widgets de GTK, o cualquier otra biblioteca de widgets que implemente las interfaces de ATK. Las dos cosas más comunes que debe hacer en este caso son:

- proporcione descripciones de algunos controles e imágenes usando `atk_object_set_description()` o `atk_image_set_description():`

  #### Establecer la descripción accesible para un botón

      {
         AtkObject *obj;
         obj = gtk_widget_get_accessible(button);
         atk_object_set_description(obj,_("Abre el diálogo de preferencias"));
      }

- Especifique la relación entre cualquier agrupación inusual de widgets usando `atk_relation_new()` y `atk_relation_set_add()`:

  #### Especificar la relación accesible entre dos controles

      {
        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));
      }

Los ejemplos en el resto de esta sección son mayoritariamente para que se haga una idea del alcance de ATK. Cubren técnicas que puede que nunca necesite usar como desarrollador de una aplicación, aunque pueden ser de interés si está escribiendo su propia modificación de los widgets (consulte Construir componentes accesibles personalizados) o si quiere escribir una aplicación de tecnología asistida. Sea cual sea el propósito, los servicios del código fuente de GAIL son un excelente tutorial para conocer el uso avanzado de ATK. Tenga en cuenta que desde la versión 3.1.10 de GTK+, Gail se ha incluido en GTK+ y ya no es un módulo independiente.

#### Módulos GTK

Los programas que hacen uso de GAIL (la biblioteca de implementación de accesibilidad para los widgets de GTK) se escriben como módulos de GTK. Los módulos de GTK se cargan en el espacio del programa si la variable de entorno `GTK_MODULES` especifica el nombre o los nombres de la biblioteca del módulo. Si hay varias bibliotecas de módulos, sepárelas con dos puntos (:). Por ejemplo:

`setenv GTK_MODULES "libgail:libtestprops"`

Todos los módulos GTK tienen una función `gtk_module_init()`.

#### Obtener la información de accesibilidad de una aplicación

Un programa que quiera hacer llamadas ATK debería hacer una, o más, de las siguientes:

1. Crear un vigilante de eventos, por ejemplo con la función `atk_add_focus_tracker()`:

       atk_add_focus_tracker (_my_focus_tracker);

   donde `_my_focus_tracker()` es una función con este prototipo:

       void _my_focus_tracker (AtkObject *aobject);

2. Configurar un detector de eventos globales, con atk_add_global_event_listener():

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

   donde `_my_global_listener` tiene el prototipo de un `GSignalEmissionHook` de Glib . Este ejemplo podría hacer que la función `_my_global_listener()` se llamara cada vez que ocurra una señal «enter_notify_even» en un objeto `GtkWidget`.

3. Acceder al objeto ATK de nivel superior con la siguiente llamada de función.

       AtkObject *root_obj = atk_get_root();

   Esto devuelve un `AtkObject` que contiene todos las ventanas de nivel superior del programa en ejecución. El usuario puede navegar a través de la jerarquía de objetos accediendo a la raíz de los objetos hijos, que con las ventanas del nivel superior.

#### Preguntar a la interfaz de un `AtkObject`

Una vez localizado el tipo `AtkObject` asociado a un objeto en la aplicación (ej. usando `gtk_widget_get_accessible()`), puede averiguar qué interfaces implementa de varias formas:

1. Use las macros proporcionadas `ATK_IS_...`, por ejemplo:

   - `ATK_IS_ACTION(atkobj)`

   - `ATK_IS_COMPONENT(atkobj)`

   - etc. (existe uno para cada interfaz)

   Si la macro devuelve `TRUE`, las llamadas a la interfaz se pueden hacer de forma segura sobre ese objeto ATK.

2. Prueba del tipo `AtkObject` llamando la función `atk_object_get_role()`. Cualquier tipo asignado implementa un número específico de API de ATK.

#### Establecer un manejador de señal ATK

Usando la señal `column_inserted` como un ejemplo:

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

Esto hará que se llame a la función `_my_table_column_inserted_func()` cada vez que se emita una señal «column_inserted» en el `AtkObject` `my_atk_object`.

Conectar a una señal es levemente diferente si la señal del soporte detalles. La señal `children_changed` soporta el detalle `add`. Para conectar a una señal cuando el detalle `add` también está especificado, se usa esta técnica:

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

Esto hará que se llame a la función `_my_children_changed_func()` siempre que se emita una señal `children_changed` con el detalle `add` en el `AtkObject` `my_atk_obj`.

#### Implementar un objeto ATK

Tendrá que implementar sus propios objetos ATK para cualquier widget que todavía no tenga una implementación accesible en GAIL (o en la biblioteca equivalente para otro conjunto de widgets). Esto debería implementarse como un módulo de GTK, que, como antes, debe incluirse en la variable de entorno `GTK_MODULES` ya que se carga en tiempo de ejecución.

##### Registro

Para este ejemplo se asume que hay un objeto llamado «GTK_TYPE_MYTYPE». La implementación de ATK se llamará `MYATKIMP_TYPE_MYTYPE`. Será necesaria una factoría, que se llamará `MYATKIMP_TYPE_MYTYPE_FACTORY`.

Para registrar una implementación ATK de un objeto GTK, se deben seguir estos pasos en la función `gtk_module_init()` del módulo:

1. Acceso al registro predeterminado:

       default_registry = atk_get_default_registry();

2. Registrar el objeto ATK en la función `gtk_module_init()` de este módulo haciendo esta llamada a la función:

       atk_registry_set_factory_type (default_registry, GTK_TYPE_MYTYPE,
       MYATKIMP_TYPE_MYTYPE_FACTORY);

Esto registrará la implementación AtkObject de `GTK_TYPE_MYTYPE` en `MYATKIMP_TYPE_MYTYPE_FACTORY`. Esta factoría se implementará para que sepa cómo construir objetos de tipo `MYATKIMP_TYPE_MYTYPE`.

##### Fábrica

La factoría debe ser implementada como un hijo del tipo de clase `ATK_TYPE_OBJECT_FACTORY` y debe implementar la función `create_accessible()`. Esta función debe crear un `AtkObject` apropiado. Una factoría se puede usar para crear más de un tipo de objeto, en cuyo caso su función `create_accessible()` necesitará ser suficientemente inteligente para construir y devolver el `AtkObject` correcto.

##### Implementación ATK para un objeto específico

Todos los `GObject` implementan una función `get_type()`. Usando el ejemplo anterior, la convención de nombres para el nombre de esta función sería `myatkimp_mytype_get_type()`.

En esta función, especifique qué interfaces implementa su objeto. Si la siguiente lógica se incluyese en esta función `get_type()`, este objeto podría implementar la interfaz del tipo `ATK_TEXT`:

###### Ejemplo de función `get_type()`

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

    g_type_add_interface_static (type, ATK_TYPE_TEXT,
                                 &atk_text_info);

La función `atl_text_interface_init()`, que tiene el siguiente prototipo, deberá implementarse:

    void atk_text_interface_init (AtkTextIface *iface);

Esta función conectará las llamadas de función de interfaz con la implementación específica tal y como sigue:

###### Conectar llamadas de interfaz personalizadas con una implementación de un AtkObject

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

Entonces podría ser necesario implementar las funciones `myatkimp_mytype_get_text()`, `myatkimp_mytype_get_character_at_offset()`, y el resto de las funciones `ATK_TEXT` de la interfaz.

##### Implementación de `AtkObject`

Los `AtkObject` son `GObjects`, y todos los `GObject` necesitan especificar la función `get_type()`. Aquí hay un ejemplo que establece una clase e inicializa una instancia. Esta función `get_type()` también especifica que el objeto implementa `ATK_TEXT` y especifica el objeto padre para ser `MYATKIMP_MYPARENTTYPE`.

###### Ejemplo de implementación de `get_type()`

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

       if (!type)
       {
          static const GTypeInfo tinfo =
          {
             sizeof (GailLabelClass),
             (GBaseInitFunc) NULL,                              /* inicialización de la base */
             (GBaseFinalizeFunc) NULL,                          /* finalización de la base */
             (GClassInitFunc) myatkimp_mytype_class_init,       /* inicialización de la clase */
             (GClassFinalizeFunc) NULL,                         /* finalización de la clase */
             NULL,                                              /* datos de la clase */
             sizeof (GailLabel),                                /* tamaño de la instancia */
             0,                                                 /* número de reservas de memoria («preallocs») */
             (GInstanceInitFunc) myatkimp_mytype_instance_init, /* inicialización de la instancia */
             NULL                                               /* tabla de valores */
          };

          /* Configurar la estructura atk_text_info usada a continuación */
          static const GInterfaceInfo atk_text_info =
          {
             (GInterfaceInitFunc) atk_text_interface_init,
             (GInterfaceFinalizeFunc) NULL,
             NULL
          };

          /* Establecer el tipo de nombre y especificar el tipo de padre */
          type = g_type_register_static (MYATKIMP_MYPARENTTYPE,
                "MyatkimpMytype", &tinfo, 0);

          /* Esta clase implementa la interfaz ATK_TYPE_TEXT */
          g_type_add_interface_static (type, ATK_TYPE_TEXT,
                                       &atk_text_info);
       }
       return type;
    }

##### Inicializadores de clases/instancias

Deberá tener creada un inicializador de clases para el `GObject` si su implementación de `AtkObject`:

1. Redefina cualquier llamada de función por el padre del objeto. Generalmente esto es necesario cuando un objeto necesita implementar una función como `atk_object_get_n_accessible_children()`. Es necesario si el objeto tiene hijos pero no están representados con los widgets.

   Por ejemplo, si su implementación de ATK necesita pasar por encima del tipo `AtkObject` de la función `get_name()`, entonces las clases inicializadas podrían ser así:

   ###### Inicializador de clase que sobreescribe la función padre `get_name()`

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

2. Requere una función `parent->init`, `parent->notify_gtk`, o `parent->finalize`. Este ejemplo define las tres:

   ###### Inicializador de clases que define su propia función `init()`, `notify_gtk()` y `finalize()`

       static ParentObjectType *parent_class = NULL;

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

          /*
           * Es necesario almacenar en caché «parent_class» si se
           * configuran las funciones init, notify_gtk, o finalize.
           */
           parent_class = g_type_class_ref (MYATKIMP_TYPE_PARENT);

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

   1. parent->init

      Se puede necesitar una función `parent->init()` si la implementación de ATK necesita hacer cualquiera de las siguientes:

      1. Cachear cualquier dato obtenido desde un respaldo del widget de GTK.

      2. Escuche cualquier señal desde el widget GTK de respaldo.

      Aquí hay un ejemplo de ambas:

      ###### Una función `init()` personalizada

          void
          gail_tree_view_widget_init (MyatkimpMytype  *mytype,
                                      GtkWidget       *gtk_widget)
          {
             /* Asegúrese de llamar a la función de inicio de los padres */
             parent_class->init (widget, gtk_widget);

             /* Caché un valor en la implementación de ATK */
             mytype->cached_value = gtk_widget_function_call();

             /* Esperar una señal */
             gtk_signal_connect (GTK_OBJECT (gtk_widget),
                                 "signal-type",
                                 GTK_SIGNAL_FUNC (_myatkimp_mytype_signal_type),
                                 NULL);
          }

      En este ejemplo, si la señal especificada `signal-type` se generase en el respaldo de `gtk_widget`, entonces se podría llamar a la función `_myatkimp_mytype_signal_type()`.

   2. parent->notify_gtk

      Si la implementación de ATK necesita escuchar cualquier notificación de propiedad en el respaldo del objeto GTK, podría ser necesaria una función `parent->notify_gtk()`. Por ejemplo:

      ###### Una función `notify_gtk()` personalizada

          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)
             {
                /* Gestionar el cambio de la propiedad. */
             }
             else
             {
                parent_class->notify_gtk (obj, pspec);
             }
          }

   3. parent->finalize

      Si es necesario para liberar cualquier dato cuando se destruye una instancia de `GObject`, entonces se necesita una función `finalize()` para liberar la memoria. Por ejemplo:

      ###### Una función `finalize()` personalizada

          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);
          }

### Hacer accesibles componentes personalizados

Añadir soporte de ATK en su widget personalizado asegurará su cooperación con la infraestructura de accesibilidad. Estos son los pasos generales necesarios:

- evaluar un widget personalizado de acuerdo a las Guías de la interfaz de usuario;

- determinar qué interfaces de ATK debería implementar un widget personalizado, de acuerdo a la característica del widget establecido y la funcionalidad;

- evaluar qué interfaces de ATK pueden heredarse desde la clase del widget padre;

- implementar las interfaces apropiadas de ATK para la clase de widget de una o dos formas:

  - directamente a través del widget personalizado o

  - en un subtipo `AtkObject` creado por una nueva subclase `AtkObjectFactory`

  Si se usa el segundo método, se debe registrar el tipo de factor apropiado con el `AtkObjectFactoryRegistry` en tiempo de ejecución.

El código fuente de GAIL sirve como un excelente turorial para el uso avanzado de ATK.

### Guías de interfaz de usuario para soportar accesibilidad

Cuando diseñe la IGU de su aplicación, existen ciertas guías simples que debería seguir para asegurarse de que puede usarse por tanta gente como sea posible, ya sea con tecnologías de asistencia o sin ellas. No sea tonto pensando que esto es sólo en caso de «hacer que su interfaz gráfica de usuario pueda usarse por personas discapacitadas», aunque, y ya que usted no debe molestarse si sabe que una persona con discapacidad nunca va a usar la aplicación. Siguiendo estas directrices mejorará la usabilidad general de su aplicación para todos los que lo usen, incluyéndole a usted.

#### General

Todos el mundo se siente frustrado si no puede encontrar una característica en una aplicación, o comete un error que tarda un par de minutos en recuperarse, si es posible recuperarse del todo. Si usted tiene algún tipo de discapacidad, el esfuerzo y el tiempo perdidoserá varias veces peor. Siguiendo algunas pautas básicas puede ayudar a prevenir este tipo de situaciones para todos los usuarios.

- Proporcione «Deshacer» para cada acción que cambie los datos del usuario o la configuración de la aplicación. Si es posible, proporcione más de un nivel de deshacer y rehacer, y una lista del histórico para permitir un vista previa de qué acciones se pueden deshacer.

- Proporcione comandos para restaurar la configuración predeterminada. Si una configuración particular puede hacer la aplicación completamente inservible para un individuo, por ejemplo, haciendo que las tipografías sean muy pequeñas, sería útil proporcionar una opción para restaurar la configuración predeterminada fuera de la propia aplicación. Esto podría hacerse, por ejemplo, mediante un interruptor de línea de comandos.

- La ayuda evita que los usuarios hagan mal las cosas. Es particularmente importante para las acciones que se puedan hacer de forma accidental (por ejemplo, las acciones del ratón) o algo que no se puede deshacer fácilmente (por ejemplo, sobrescribir un archivo). Considere usar los diálogos de confirmación o forzar al usuario para entrar en un modo particular para llevar a cabo acciones potencialmente destructivas.

- Minimize la carga de memoria de los usuarios. Por ejemplo, deje que el usuario vea múltiples documentos al mismo tiempo, y asegurare la ayuda en línea u otras instrucciones puede permanecer visibles mientras llevan a cabo el procedimiento que se describe. Déjeles copiar toda la información mostrada, y pegarla en cualquier parte donde se puedan introducir los datos.

- No haga que los usuarios inserten discos. Dependiendo de la discapacidad particular de un usuario, pueden encontrar difícil insertar físicamente o cambiar un disco, o pueden encontrarlo para identificar el disco correcto en el primer lugar. Si su aplicación está instalada desde el CD-ROM, proporcione una opción para copiar todos los ficheros que sean necesarios en el disco duro del usuario.

- No coloque funciones más utilizadas muy profundas en los menús. Ya sea que usted está usando un ratón, teclado o algún otro dispositivo de entrada, es mejor evitar los elementos de menú profundamente anidados. Así como la carga de memoria sobre su localización, siempre es más difícil y cuesta mucho tiempo para acceder a él.

- No guíe a los usuarios a través de pasos innecesarios. Por ejemplo, los asistentes son útiles para los usuarios que tienen problemas para manejar un gran número de opciones a la vez, pero otros usuarios pueden necesitar minimizar la cantidad de tiempo o las pulsaciones de teclado que utilizan. Dichos usuarios se benefician de la posibilidad de saltarse los pasos innecesarios o de ir directamente a la que necesitan. Considere la posibilidad de proporcionar un botón Finalizar en los asistentes que permitan saltar hasta el final y asumir las respuestas predeterminadas para los pasos intermedios. Si el proceso tiene muchos pasos, considere preguntar al usuario al inicio si se quiere atravesar todos los pasos, o simplemente los más comúnmente utilizados.

#### Navegación por teclado

Una interfaz de teclado de usuario bien diseñada juega un papel clave al diseñar el software de accesibilidad. Los usuarios ciegos pueden navegar por el software más eficazmente usando el teclado, ya que con el ratón depende de la percepción visual de la posición del puntero del ratón. Además, los problemas de movilidad pueden evitar que un usuario se mueva con éxito usando el ratón, debido a las habilidades necesarias para la motricidad final de control.

Por lo tanto es importante hacer todas las acciones del ratón disponibles desde el teclado, e incluir el acceso al teclado para todas las barras de herramientas, menús, enlaces y botones. Cada función proporciona que su aplicación puede está disponible usando sólo el teclado. Si es necesario, su ratón se oculta mientras está utilizando su aplicación.

La mayoría de la funcionalidad debería ser fácil para hacerla accesible usando atajaos del teclado y aceleradores, y el conjunto de herramientas integrado en las funciones de navegación. Sin embargo, las operaciones que dependen de arrastrar y colocar, por ejemplo, puede requerir un mayor conocimiento.

- Facilite el acceso eficiente del teclado a todas las funciones de la aplicación. Algunos usuarios pueden ser incapaces de usar un ratón, y muchos «usuarios avanzados» prefieren usar el teclado de todos modos. Además, algunas tecnologías de asistencia especializadas con dispositivos de entrada pueden simular los eventos del teclado mejor que los eventos del ratón. Ya que que para algunos usuarios la escritura es difícil o incluso dolorosa, es importante proporcionar un interfaz del teclado que minimize el número de las pulsaciones requeridas para cualquier tarea.

- Use un orden de navegación de teclado lógico. Al navegar alrededor de una ventana con la tecla Tab, el foco del teclado debería moverse entre los controles en un orden predecible. En configuraciones regionales occidentales, ésto normalmente es de izquierda a derecha y de arriba a abajo.

- Garantice el orden correcto de la etiquetas para los controles que permitieron el estado depende de la casilla de verificación, botón de opción o botón de alternar el estado. Cuando un botón se selecciona, todos sus controles dependientes deben estar habilitados y todos los controles que dependan de cualquier otro botón del grupo se deben desactivar. Cuando el usuario selecciona una casilla de verificación, botón de opción o el botón de alternar que tiene controles dependientes, no da automáticamente el foco al primer control dependiente, pero en su lugar deja el foco en el botón.

- No anule las características de accesibilidad existentes a nivel de sistema. Por ejemplo, AccessX es una extensión del servidor X que se ha apoyado desde X11R6. La característica «MouseKeys» de esta extensión permite el movimiento del ratón y similar las pulsaciones del botón utilizando el teclado. Por lo tanto, no debe añadir características a su aplicación que sólo se puede acceder pulsando las teclas en el teclado, ya que los usuarios basándose en la característica «MouseKeys» no podrán usarlas.

- Proporcione más de un método para realizar las tareas del teclado siempre que sea posible. Algunos usuarios pueden encontrar algunas claves y combinaciones de teclas más fáciles de usar que otras.

- Proporcione el acceso del teclado y el ratón para que funcionen a la vez donde sea posible. Algunos usuarios quizás sólo pueden usar el teclado o el ratón, pero no ambos.

- No asigne alcanza difícil de las operaciones de teclado se realizan con frecuencia. Algunas personas sólo pueden ser capaces de usar una mano en el teclado, por lo que los accesos directos que se pueden usar fácilmente con una mano, son preferibles para operaciones comunes. En cualquier caso, tener que realizar en el teclado operaciones largas o difíciles con frecuencia puede aumentar la tensión del músculo para todos los usuarios, aumentando el riesgo de dolor o lesión.

- No requiera el uso repetitivo de pulsaciones simultáneas. Algunos usuarios sólo son capaces de mantener presionado una tecla a la vez. Las tecnologías de apoyo, tales como «AccessX» pueden permitir a los usuarios presionar las teclas de forma secuencial y no simultáneamente, pero esto, por supuesto, significa que la operación tomará más tiempo para ellos.

- Asegúrese de que cualquier texto que se pueda seleccionar con el ratón también se puede seleccionar con el teclado. Esta es una comodidad para todos los usuarios, pero especialmente para aquellos para quienes un control preciso del ratón es difícil.

- Asegúrese de que los objetos que pueden ser redimensionado o movidos por arrastrar y soltar también pueden cambiar el tamaño o moverse con el teclado. Por ejemplo, los iconos y ventanas en el escritorio. Cuando la precisión del tamaño y la colocación son potencialmente importantes, por ejemplo, formas en un diagrama, considere también la posibilidad de un diálogo en el que puede escribir las coordenadas, o un medio para ajustar de objetos a una cuadrícula definida por el usuario.

- No use las funciones generales de navegación para activar las operaciones. Por ejemplo, la navegación básica de Tab con el teclado en un cuadro de diálogo para activar las acciones asociadas a un control.

- Muestre menús invocados por teclado, ventanas y sugerencias cerca del objeto que se relacionan. En GNOME 2.0, los usuarios pueden llamar a los menús emergentes con Mayús.F10, y a la información sobre las herramientas con Mayús F1. Sin embargo, no oculte u oscurezca completamente el objeto al que el menú o la descripción se refiere.

#### Interacción del ratón

Recuerde que no todo el mundo puede usar un ratón con igual destreza y que algunos usuarios pueden tener dificultad viendo o siguiendo el puntero del ratón.

- No dependa de pulsaciones de los botones 2 o 3 del ratón. Aparte de ser físicamente más difíciles de pulsar, algunos dispositivos apuntadores y muchos dispositivos con tecnología de asistencia sólo soportan el botón 1. Algunas tecnologías de asistencia pueden no emular el ratón en absoluto, pero generan eventos de teclas del teclado en su lugar.

- Permita cancelar todas las operaciones del ratón. Pulsar la tecla Esc debería cancelar cualquier operación en progreso, como arrastrar y soltar un fichero en un administrador de ficheros, o dibujar una forma en un programa de dibujo.

- Proporcione realimentación visual a través de una operación de arrastrar y soltar. A medida que el ratón pasa por encima de objetivos válidos, selecciónelos y cambie el puntero del ratón. Utilice el puntero «no drop» del ratón al pasar sobre los destinos de arrastre válidos. Consulte Ejemplos de iteración del ratón.

- No deforme el puntero del ratón, ni restrinja el movimiento del ratón a la parte de la pantalla. Esto puede interferir con las ayudas técnicas, y suele ser confusa incluso para los usuarios que no dependen de la AT.

- No haga los objetivos del ratón muy pequeños. En general, los objetivos del ratón debe ser al menos del tamaño de la «zona caliente» en todo el borde de la ventana de tamaño variable en el actual gestor de ventanas/tema; teniendo en cuenta que un usuario con motricidad disminuida o visión puede estar utilizando un gestor de ventanas con áreas más grandes de la predeterminada.

##### Ejemplos de interacción con el ratón

###### Ejemplo del puntero «no-drop» desde CDE/Motif

Ejemplo de forma del puntero «objetivo de arrastre no válido»

#### Elementos gráficos

Proporcione opciones para personalizar la presentación de todos los elementos importantes en su aplicación gráfica. Esto hará que sea más fácil de usar para las personas con discapacidades visuales o cognitivas.

- No programe atributos gráficos como la línea, el borde o el grosor de sombra. Estos elementos idealmente se deben leer desde el tema GTK o gestor de ventanas. Si esto no es posible, ofrezca opciones dentro de su aplicación para cambiarlos.

- Proporcione nombres descriptivos para todos los componentes de las interfaces. La librería de GAIL proporciona descripciones accesibles de manera predeterminada para muchos widgets GTK, pero usted todavía tendrá que añadir las suyas propias en algunos casos, como para los widgets que utilizan gráficos en lugar de texto (por ejemplo, un pozo en una paleta de colores, o un icono sin etiqueta). Considere la posibilidad de reemplazar los valores predeterminados, con descripciones más útiles o específicas de la aplicación siempre que sea posible.

- Permita elementos gráficos de varios colores (ej. iconos de barra de herramientas) que sea vean sólo en monocromo, si es posible. Estas imágenes monocromo se deben mostrar en los colores de primer plano y de fondo del sistema, que cada usuario habrá elegido (al elegir el tema de GTK), para una legibilidad máxima.

- Haga que los elementos interactivos de la IGU se identifiquen fácilmente. Por ejemplo, no haga que el usuario pase el ratón sobre un objeto para determinar si se es pulsable o no. Deje suficiente espacio entre los objetos y delimite claramente los bordes de los objetos. No muestre los elementos de IGU que son bonitos, pero en realidad no hacen nada, a menos que también proporcione una opción para desactivarlos.

- Proporcione una opción para ocultar los gráficos que no transmitan información esencial. Las imágenes gráficas pueden distraer a los usuarios con algunas desórdenes cognitivos. Los iconos en el menú del pie de GNOME, por ejemplo, se pueden quitar mientras sigue dejando los menús completamente funcionales.

#### Tipografías y textos

Incluso para un usuario con visión normal, la salida textual proporciona la mayor parte de la información y la retroalimentación en la mayoría de las aplicaciones. Por tanto, es crítico elegir la posición del texto con cuidado en la pantalla, y dejar la elección de la fuente y el tamaño para el usuario, para garantizar que las personas con visión deteriorada puede también utilizar su aplicación eficazmente.

- No programe estilos de tipografías ni tamaños. El usuario debería ser capaz de ajustar todos los tamaños y tipos de letras. Si por alguna razón no puede hacer esta funcionalidad disponible, nunca programe una tipografía con un tamaño inferior a 10 puntos.

- Proporcione opciones para desactivar cualquier telón de fondo gráfico o «marcas de agua» detrás del texto. Tales imágenes interfieren con el contraste entre el texto y el fondo, lo que puede causar dificultad para los usuarios con impedimentos visuales.

- La etiqueta de objetos con nombres que tienen sentido cuando se toman fuera del contexto. Los usuarios que basándose en los lectores de pantalla o tecnologías de apoyo similares no necesariamente serán capaces de comprender inmediatamente la relación entre un control y aquellos que lo rodean.

- No use la misma etiqueta más de una vez en la misma ventana. Si utiliza la misma etiqueta en diferentes ventanas, ayudará si significa lo mismo en ambas ventanas. Además, no use etiquetas que se deletrean diferentemente, pero suenan igual, por ejemplo, «Read» y «Red», (N. del T.: «Leer» y «Rojo» ) ya que esto puede ser confuso para los usuarios dependientes de lectores de pantalla.

- Coloque las etiquetas de manera coherente en toda la aplicación. Esto normalmente significa inmediatamente por debajo de iconos grandes, inmediatamente a la derecha de los iconos pequeños, e inmediatamente por encima o a la izquierda de otros controles. Consulte Ejemplos de tipografías y de texto.

- Cuando se utiliza texto estático para etiquetar un control, termine la etiqueta con dos puntos. Por ejemplo, Nombre del usuario: para marcar un campo del texto en el que el usuario debe escribir su nombre. Esto ayuda a identificarlo como una etiqueta de control, en lugar de un elemento de texto independiente.

- Cuando usa texto estático para etiquetar un control, asegúrese de que la etiqueta precede inmediatamente ese control en el orden de pestañas. Esto asegurará que el mnemónico (carácter subrayado) que asigna a la etiqueta moverá el foco a o activará el control correcto al pulsarlo.

- Ofrece alternativas a WYSIWYG. Algunos usuarios pueden necesitar imprimir el texto en letra pequeña, pero editarlo en una tipografía de pantalla más grande. Las alternativas posibles incluyen mostrar todo el texto en la misma tipografía y tamaño (elegido por el usuario); una opción «ajustar a la ventana» que le permite leer todo el texto en una ventana sin necesidad de desplazarse horizontalmente; una vista de una sola columna que muestra el contenido de la ventana en una sola columna, incluso si se imprimen en varias columnas; y una vista de sólo texto, donde los gráficos se muestran como marcadores de posición o descripciones de texto. Si la aplicación tiene paneles con controles secundarios, considere la posibilidad de cambiar el tamaño de los paneles junto a la ventana madre.

##### Ejemplos de tipografías y textos

###### Ubicación correcta de etiquetas para varios elementos de la IGU

List control with label above Lista de control con etiqueta arriba | Large file manager icon with label underneath Icono del gestor de archivos de gran tamaño con etiqueta debajo de él | Small toolbar icon with label to its right Icono pequeño de barra de herramientas con etiqueta a su derecha | Spinbox control with label to its left Caja de control incremental con etiqueta a su izquierda

#### Color y contraste

Una mala elección de los colores en la pantalla puede causar problemas a los usuarios daltónicos (para los que el tono es importante) o de baja visión (para quienes el brillo y el contraste es importante). Generalmente debería permitir al usuario personalizar los colores en cualquier parte de su aplicación que transmita información importante.

Los usuarios con impedimentos visuales pueden requerir un alto nivel de contraste entre los colores de fondo y texto. A menudo se usa un fondo negro y texto en blanco para prevenir el fondo de «sangrado» más. Estos ajustes son críticos para los usuarios con impedimentos visuales.

- No programe en el código los colores de las aplicaciones. Algunos usuarios necesitan usar determinadas combinaciones de colores y niveles de contraste para poder leer la pantalla cómodamente. Por lo tanto todos los colores principales que su aplicación de GNOME usa, se deben tomar desde el tema GTK, para que el usuario puede configurar los colores para todas sus aplicaciones a algo legible, tan solo cambiando el tema. Si por alguna razón necesita usar colores que no están disponibles en el tema, asegúrese de que se pueden personalizar en la propia aplicación.

- No use el color como el único medio de distinguir los elementos de información. Toda esa información se debe proporcionar al menos por otro método, tales como forma, posición o descripción textual. Consulte los Ejemplos de color y contraste.

- Soporte todos los temas de alto contraste de GNOME. Asegúrese que cuando uno de estos temas está seleccionado, todo el texto de su aplicación aparece con los colores de primer plano y de fondo de alto contraste especificados por el tema.

- Asegúrese de que su aplicación no depende de un tema de alto contraste en particular. Pruebe con diferentes temas de alto contraste para asegurarse de que su aplicación respeta la configuración.

##### Ejemplos de color y contraste

###### Ejemplo que ilustra el uso redundante de color

Ejemplo que muestra los cambios en el precio usando sólo el color | Esta pantalla puede causar problemas para un usuario daltónico (el daltonismo afecta a casi 1 de cada 7 hombres en algunas partes del mundo). La falta de contraste entre el texto en rojo y el fondo negro también hace que sea difícil de leer para un usuario con visión baja, incluso con un magnificador de pantalla.
Ejemplo que muestra los cambios en el precio usando colores y flechas | Esta pantalla refuerza la codificación de los colores con flechas para indicar el movimiento de los precios, y utiliza tonos verdes y rojos más oscuros sobre un fondo más claro para proporcionar un mayor contraste. Esta no tiene por qué ser la combinación de colores predeterminada si las pruebas fueron para mostrar que es demasiado molesto para la mayoría de los usuarios, pero debería ser posible personalizarlo de esta forma, ya sea mediante un tema o a través del diálogo Preferencias de la aplicación.

#### Aumento

Muchos usuarios, incluso los que no tienen una discapacidad visual, se benefician de magnificación del texto y de los gráficos. Sin embargo, sin magnificación, un usuario con discapacidad visual no puede acceder ni utilizar el programa el absoluto.

- Proporcione al usuario la posibilidad de magnificar el área de trabajo.

- Proporcione opciones en la aplicación para escalar el área de trabajo. Los usuarios necesitan tener una opción para magnificar el área de trabajo entre un 150% y un 400%. Verifique la aplicación para confirmar que el objeto que está viendo no se ve afectado al cambiar la configuración de la magnificación.

#### Sonido

Las personas que tienen dificultades auditivas, así como aquellas que trabajan con el sonido del equipo apagado, estarán en desventaja si su aplicación se basa en el sonido para transmitir información. En general, asegúrese de que el usuario puede recibir la información audible de otras maneras.

- No dé por hecho que el usuario oirá la información sonora. Esto se aplica tanto a usuarios con tarjetas de sonido estropeadas como a aquellos que tienen problemas auditivos.

- No use el sonido como la única manera de transmitir información. Dé al usuario la posibilidad de tener toda la información sonora de una manera visual. Esto implica proporcionar subtítulos o transcripciones de todos los fragmentos de sonido hablados importantes.

- Permita a los usuarios configurar la frecuencia y el volumen de los pitidos de aviso y otros sonidos. Esto incluye poder apagar el sonido por completo.

#### Animación

Usada con moderación, la animación puede ser útil para llamar la atención sobre información importante en su aplicación; y también puede quedar bien. Sin embargo, puede ser problemático para algunos usuarios, así que asegúrese de que se puede desactivar.

- No use elementos que parpadeen o destellen con una frecuencia mayor de 2 Hz ni inferior a 55 Hz. Esto incluye el texto y los objetos gráficos. Cualquier cosa en este rango de frecuencias puede causar problemas a los usuarios susceptibles de convulsiones por inducción visual. Tenga en cuenta que, sin embargo, no hay una frecuencia «segura». Si los destellos son esenciales, debería usar la frecuencia de parpadeo del cursor del sistema (que debería ser configurable), o permitir a los usuarios configurar la frecuencia ellos mismos.

- No haga que destellen o parpadeen áreas grandes de la pantalla. Las áreas pequeñas son menos propensas a provocar convulsiones en quienes son susceptibles a ellas.

- Haga todas las animaciones opcionales. La información animada debería estar disponible en al menos un formato no animado, a elección del usuario.

#### Foco del teclado

Mostrar la posición del foco del teclado claramente en todo momento es importante, tanto para los usuarios con problemas visuales, como para «usuarios avanzados» que prefieren usar el teclado en lugar del ratón. No debería haber ninguna confusión en cuanto a qué control tiene del escritorio tiene el foco en un momento dado. Debe ser capaz de dejar el equipo con el foco en cualquier control de su aplicación, irse y llamar por teléfono a su novia o pasear al perro hasta olvidar en que widget lo dejó en. Cuando vuelva, debería ser capaz de decir exactamente en qué widget estaba.

Un indicador visual del foco es una representación sonora de la posición del cursor en relación con el resto de objetos del escritorio. Esto permite al usuario moverse entre los objetos de forma interactiva a medida que cambia el foco. El foco visual se debe exponer mediante programación a las tecnologías de asistencia. Tenga en cuenta que en la mayoría de los casos, esto lo maneja ATK automáticamente, sin necesidad de realizar ningún trabajo adicional. Sin embargo, tendrá que tener en cuenta este requisito al escribir sus propios widgets personalizados, por ejemplo.

- Inicie el foco en el control mas usado habitualmente. Si no hay control en una ventana considerada la «más» útil, inicie el foco en el primer control de la ventana cuando esta se abra. El foco no debería iniciarse en los botones Aceptar ni Cancelar de un diálogo, aunque sean los controles más usados habitualmente, ya que se pueden activar inmediatamente pulsando Intro o Esc.

- Muestre claramente el foco de entrada actual todas las veces. Recuerde que los controles que incluyen un elemento deslizante, no siempre es suficiente resaltar sólo el elemento seleccionado dentro del área de desplazamiento, ya que puede no ser visible. Consulte los ejemplos de foco del teclado.

- Muestre el foco de entrada sólo en la ventana activa. Oculte todos los indicadores visuales del foco principales en todas las ventanas que no tienen el foco ni la activación. Si una única ventana tiene paneles separados, sólo uno de los paneles deben tener el indicador del foco, y los indicadores del foco deben estar escondidos en el resto de paneles. Si es importante seguir mostrando qué elemento de una lista sin foco está seleccionado, por ejemplo, use un indicador de foco secundario. Consulte los ejemplos de foco del teclado.

- Proporcione comentarios adecuados cuando el usuario intenta navegar más allá del final de un grupo de objetos relacionados. Al navegar por una lista, por ejemplo, pararse con comentarios sonoros es preferible a mover el foco al primer objeto en la lista. De lo contrario, los usuarios que son ciegos o con baja visión podrían no darse cuenta de que han regresado al principio. En el caso de una búsqueda de texto en un documento, puede aparecer un cuadro de diálogo para indicar que se ha alcanzado el final del documento, y le preguntará si quiere reanudar la búsqueda desde el principio del documento.

- Reproduzca la señal de alerta sonora o visual predeterminada del sistema cuando el usuario pulse una tecla inadecuada, o cuando falle una tecla de navegación para mover el foco. Por ejemplo, cuando el foco está en el primer carácter en un campo de texto y el usuario presiona la tecla izquierda de flecha, o el usuario intenta realizar una selección múltiple en un diálogo de selección única. (Tenga en cuenta que los usuarios con dificultades de audición debe ser capaz de configurar un equivalente visual de todo el sistema con la alerta sonora predeterminada.)

##### Ejemplos de foco del teclado

###### Ejemplo que ilustra la necesidad de mostrar el foco con claridad

El elemento con el foco en esta ventana no se puede ver porque se ha desplazado fuera de la ventana | Uno de los controles de esta ventana tiene el foco, pero es imposible decir cuál...
El elemento con el foco en la lista se ha traído a la vista desplazando la vista | ...hasta que desplaza la lista, lo que revela que uno de los elementos está actualmente seleccionado.
El control de lista de este ejemplo tiene un borde sólido que indica el foco, si su elemento seleccionado está visible actualmente o no. | Si el control de lista tiene un borde «enfocado», es fácil decir que tiene el foco incluso cuando el elemento seleccionado actualmente no es visible.

###### Ejemplo que ilustra el uso de foco secundario

Ventana dividida en paneles en la que ambos paneles parecen tener el foco | En este ejemplo, es imposible decir, simplemente mirando, cuál de los dos paneles tiene actualmente el foco del teclado.
Ventana dividida en paneles en la que el resaltado secundario se usa para mostrar qué panel tiene el foco | Usando un color de selección de relieve secundario en el panel inactivo, es obvio que el control de árbol tiene el foco aquí...
Ventana dividida en paneles en la que el resaltado secundario se usa para mostrar qué panel tiene el foco | ... y que el control de lista tiene el foco aquí.

#### Sincronización

Interfaces en las aparecen o desaparecen cosas o se producen de acuerdo a un límite de tiempo codificado de manera que no se puede variar, son a menudo un obstáculo a la accesibilidad. Algunos usuarios pueden leer, escribir o reaccionar muy lentamente en comparación con otros. Si la información que requieren se oculta antes de terminar con ella, o la tapa otro tipo de información que aparece sin que la soliciten expresamente, la aplicación será muy frustrante o imposible de usar.

- No programe los tiempos de espera ni otras características basadas ​​en el tiempo. Los ejemplos incluyen el desplazamiento automático al arrastrar un objeto hacia el borde de una ventana, manteniendo pulsado un botón de la barra de desplazamiento, o la expansión automática de un nodo del árbol cuando se arrastra un objeto sobre él y se mantiene durante un corto tiempo. Estos se deberían poder personalizar en la aplicación, en el Centro de control de GNOME o, en el peor de los casos, poder editarse manualmente desde la línea de comandos a través de un archivo de configuración o una entrada de GConf.

- No muestre ni oculte brevemente la información basada en el movimiento del puntero del ratón. (Excepción: el sistema proporciona características tales como consejos, que el usuario puede configurar a nivel de todo el sistema). Si tiene que proporcionar estas características, haga que sean opcionales para que los usuarios puedan desactivarlas cuando se instala una utilidad para revisar la pantalla.

#### Documentación

Las personas con discapacidades no pueden usar aplicación de manera efectiva si no tienen acceso a los manuales requeridos ni a los archivos de ayuda. Especialmente importante es la navegación con el teclado, ya que es la única manera en que muchos usuarios puede moverse por la aplicación.

- Proporcione toda la documentación en un formato accesible. HTML y texto en ASCII son formatos excelentes para las tecnologías de asistencia.

- Proporcione descripciones de texto alternativas para todos los gráficos de la documentación.

- Documente todas las características de accesibilidad de su aplicación. Es especialmente importante que se documenten la navegación con el teclado y los atajos. incluya una sección de accesibilidad en su documentación, donde se pueda encontrar información sobre todas las características de accesibilidad.

## Pruebas

Hay varios puntos de revisión que llevar a cabo antes de declarar una aplicación accesible. Durante el desarrollo, se pueden considerar técnicas de pruebas automatizadas. LDTP, por ejemplo, puede complementar su plan de pruebas automatizadas.

Esta sección describe una serie de pruebas que puede realizar manualmente en una aplicación para comprobar su accesibilidad. Superar todas las pruebas no implica necesariamente que la aplicación sea completamente accesible, pero si la aplicación falla en alguna de estas pruebas, el futuro trabajo debe ser mejorar estos aspectos de la accesibilidad.

### Navegación por teclado

Se deberían probar las siguientes operaciones con el teclado. No use el ratón en ninguna parte de esta prueba.

- Usando sólo comandos del teclado, mueva el foco a través de todas las barras de menús de la aplicación.

- Confirme que:

  - Los menús sensitivos de contexto se muestran correctamente.

  - Cualquier función listada en la barra de herramientas se puede realizar usando el teclado.

  - Puede manejar todos los controles en el área de cliente de la aplicación y en los cuadros de diálogo.

  - El texto y los objetos en el área del cliente se pueden seleccionar.

  - Cualquier atajo o mejora de teclado funciona como se ha diseñado.

### Elementos gráficos

Pruebe la aplicación usando un lector de pantalla y confirme que:

- Las etiquetas y el texto se leen correctamente, incluyendo los menús y las barras de heramientas.

- La información del objeto se lee correctamente.

### Indicador visual del foco

- Verifique que cuando se mueve entre objetos el indicador visual del foco es fácil de identificar.

- La navegación con el teclado a través del software y de los menús debería ser claramente visible cuando se mueve el foco.

- Confirme que el lector de pantalla sigue el indicador de foco visual a medida que navega usando el teclado.

- Ejecute un programa de magnificación de la pantalla (si está disponible) y compruebe que el magnificador puede seguir el indicador de foco visual a medida que navega usando el teclado y el ratón.

### Tipografías y textos

- Cambie la tipografía en la aplicación y confirme que los cambios se mantienen.

- Pruebe la aplicación cambiando los colores y confirme que toda la configuración se mantiene.

- Si la magnificación está disponible, comprobar la tipografía, color y tamaño al usar la opción de magnificación.

### Color y contraste

- Imprima capturas de pantalla en una impresora en blanco y negro y confirme que toda la información es visible.

- Pruebe aplicaciones usando sólo los ajustes de alto contraste de blanco y negro y confirme que toda la información se transmite correctamente.

- Compruebe que la aplicación proporciona al menos tres combinaciones de esquemas de color y que están disponibles los esquemas de alto contraste (ej. blanco sobre negro o amarillo sobre azul).

- Active las características de contraste alto en el Centro de control de GNOME y confirmar que la aplicación respeta esos ajustes.

- Pruebe varios temas para asegurarse de que el software funciona para todos los ajustes disponibles.

### Sonido

Debe existir una opción en la aplicación para mostrar visualmente las alertas de sonido.

Compruebe que el sonido funciona correctamente activando el sonido en el Centro de control de GNOME y realizando después las siguientes acciones:

- Realice una acción que debe generar una alerta de sonido y confirme que la aplicación funciona como se ha diseñado.

- Compruebe que la aplicación funciona correctamente al aumentar o reducir el volumen.

- Confirme que los mensajes de advertencia y alertas se pueden oír correctamente en un entorno de trabajo ruidoso.

### Animación

Compruebe que existe una opción disponible para detener la animación y que funciona como se ha diseñado.

Desactive la animación. Confirme que aún así se hace llegar correctamente toda la información.

### Foco del teclado

- Compruebe todos los mensajes para confirmar que se le notifica al usuario antes de que un mensaje caduque y se da la opción de indicar que se necesita más tiempo.

- Asegúrese de que se ha incluido una opción para ajustar el tiempo de respuesta y confirme que funciona como se ha diseñado.

### Documentación

Compruebe la documentación de texto ASCII con un lector de pantalla para comprobar que es limpia y precisa y las tecnologías de asistencia la pueden leer.

Compruebe que las aplicaciones HTML que usan un navegador web y el lector de pantalla confirman que la documentación es accesible a las tecnologías de asistencia.

Nota: existen guías de accesibilidad web disponibles en http://www.w3.org/TR/WAI-WEBCONTENT/.

Confirme que la siguiente información se incluye en la documentación:

- Plantee si la aplicación no soporta los accesos de teclado estándar usados por el Sistema Operativo.

- Identifique si existen comandos únicos de teclado.

- Identifique cualquier característica única de accesibilidad.

- Si una acción se documenta para el ratón, asegúrese de que existe una alternativa para usar el teclado.

### Lista de comprobación de la interfaz de usuario

Esta sección resume las guías proporcionadas en la Guías de interfaz de usuario para soportar accesibilidad. Debe referirse a esa sección de la guía para obtener información más detallada sobre cualquiera de los elementos de la lista de comprobación aquí proporcionados.

Al comprobar una aplicación para su accesibilidad debería ir a través de cada uno de los elementos de la lista. Notar si la aplicación pasa o falla cada comprobación o no se aplica a dicha comprobación.

### Lista de comprobación de los principios generales

PG | Principios generales | Pasa/Falla/No aplicable
PG.1 | Se puede deshacer cada acción que altera los datos del usuario o la configuración de una aplicación.
PG.2 | Toda la configuración de las aplicaciones se puede restaurar a sus valores predeterminados sin que el usuario tenga que recordar cuáles eran esos valores.
PG.3 | Después de la instalación, la aplicación se puede usar sin que el usuario tenga que introducir un disco o CD en ningún momento.
PG.4 | Las funciones más frecuentemente usadas se encuentran en la parte superior de la estructura del menú.

### Lista de comprobación de la navegación por teclado

NT | Navegación por teclado | Pasa/Falla/No aplicable
NT.1 | Se proporciona acceso eficiente al teclado para todas las características de la aplicación.
NT.2 | Todas las ventanas tienen un orden lógico de navegación por teclado.
NT.3 | Se usa el orden correcto de tabulación para los controles cuyos estados activados dependen de cajas de verificación, botones de radio o botones de conmutación.
NT.4 | El acceso a las funciones específicas de la aplicación a través del teclado no anulan las características de accesibilidad del sistema.
NT.5 | La aplicación proporciona más de un método para realizar tareas con el teclado, siempre que sea posible.
NT.6 | Existen combinaciones de teclas alternativas siempre que sea posible.
NT.7 | No existen combinaciones incómodas de alcanzar para operaciones de teclado realizadas frecuentemente.
NT.8 | La aplicación no usa pulsaciones de teclado simultáneas y/o repetitivas.
NT.9 | La aplicación proporciona equivalentes de teclado para todas las funciones del ratón.
NT.10 | Cualquier texto u objeto que se puede seleccionar con el ratón también se puede seleccionar sólo con el teclado.
NT.11 | Cualquier objeto que se puede redimensionar o mover con el ratón también se puede redimensionar y mover sólo con el teclado.
NT.12 | La aplicación no usa funciones de navegación generales para disparar operaciones.
NT.13 | Todos los menús, ventanas y consejos invocados con el teclado aparecen junto al objeto al que están relacionados.

### Lista de comprobación de la interacción con el ratón

IR | Interacción del ratón | Pasa/Falla/No aplicable
IR.1 | Ninguna operación depende de la entrada de los botones derecho o central del ratón.
IR.2 | Todas las operaciones con el ratón se pueden cancelar antes de que se completen.
IR.3 | Se proporciona contexto visual a en todas las operaciones de arrastrar y soltar
IR.4 | El puntero del ratón nunca se ajusta bajo el control de la aplicación, o la aplicación restringe su movimiento se restringe a parte de la pantalla.

### Lista de comprobación de los elementos gráficos

EG | Elementos gráficos | Pasa/Falla/No aplicable
EG.1 | No existen atributos gráficos incrustados e inmutables («hard-coded») tales como el grosor de las líneas, bordes o sombras.
EG.2 | Todos los elementos gráficos multicolor se pueden mostrar en monocromo, siempre que sea posible.
EG.3 | Todos los elementos interactivos del IGU son fácilmente distinguibles desde elementos del IGU estáticos.
EG.4 | Se proporciona una opción para ocultar los gráficos no esenciales.

### Lista de comprobación de las tipografías y del texto

TT | Tipografías y textos | Pasa/Falla/No aplicable
TT.1 | No hay estilos o tamaños incrustados e inmutables («hard-coded»)
TT.2 | Se proporciona una opción para desactivar los fondos gráficos detrás del texto.
TT.3 | Todas las etiquetas deben tener nombres que tengan sentido al sacarlas de contexto.
TT.4 | No se usa más de una vez el mismo nombre de etiqueta en la misma ventana.
TT.5 | La posición de las etiquetas es consistente en toda la aplicación.
TT.6 | Todas las etiquetas de texto estático que identifican otros controles terminan con dos puntos (:).
TT.7 | Las etiquetas de texto estático que identifican otros controles preceden inmediatamente a esos controles en el orden de las pestañas.
TT.8 | Se proporciona una alternativa a «WYSIWYG» (lo que se ve es lo que se obtiene). Por ejemplo, la capacidad de especificar una pantalla diferente o tipografías de impresión diferentes en un editor de textos.

### Lista de comprobación del color y contraste

CC | Color y contraste | Pasa/Falla/No aplicable
CC.1 | Los colores de la aplicación no están incrustados ni son inmutables («hard-coded»), sino que se dibujan desde el tema actual del escritorio o desde un ajuste de la aplicación.
CC.2 | El color sólo se usa como mejora y no como el único medio de comunicar información u acciones.
CC.3 | La aplicación soporta todos los temas y ajustes de los temas de alto contraste.
CC.4 | El software no depende de ningún tema de alto contraste o ajuste en particular.

### Lista de comprobación de la magnificación

MG | Aumento | Pasa/Falla/No aplicable
MG.1 | La aplicación proporciona la capacidad de magnificar el área de trabajo.
MG.2 | La aplicación proporciona la opción de escalar el área de trabajo.
MG.3 | La funcionalidad de la aplicación no se ve afectada por cambiar la magnificación o los ajustes de escala.

### Lista de comprobación del sonido

SO | Sonido | Pasa/Falla/No aplicable
SO.1 | El sonido no se usa como el único medio de comunicación de cualquier elemento de información.
SO.2 | El usuario puede configurar la frecuencia y volumen de todos los sonidos y pitidos de advertencia.

### Lista de comprobación de animaciones

AN | Animación | Pasa/Falla/No aplicable
AN.1 | No existe ningún elemento que destelle o parpadee con una frecuencia mayor de 2Hz o menor de 55Hz.
AN.2 | Cualquier destello o parpadeo está confinado en pequeñas áreas de la pantalla.
AN.3 | Si se usa una animación existe una opción disponible para desactivarla antes de que se muestre por primera vez.

### Lista de comprobación del foco del teclado

FT | Foco del teclado | Pasa/Falla/No aplicable
FT.1 | Al abrir una ventana el foco está en el control más usado.
FT.2 | La posición del foco de entrada está claramente mostrada en todo momento.
FT.3 | El foco de entrada se muestra exactamente en una ventana en todo momento.
FT.4 | Se proporciona el contexto sonoro o visual apropiado cuando el usuario intenta navegar más allá del límite de un grupo de objetos relacionados.
FT.5 | La señal de advertencia sonora o visual predeterminada se reproduce cuando el usuario pulsa una tecla inapropiada.
FT.6 | Existe suficiente información sonora para el foco visual tal que el usuario puede intuir qué hacer a continuación.
FT.7 | Al usar tecnologías de asistencia, tales como el lector de pantalla o un dispositivo braille, el programa actual indica la posición y contenido del indicador visual del foco.

### Lista de comprobación de los tiempos

TM | Sincronización | Pasa/Falla/No aplicable
TM.1 | En la aplicación no existen tiempos de expiración invariables en el código o características basadas en tiempo.
TM.2 | El mostrado u ocultación de información importante no se dispara exclusivamente por el movimiento del puntero del ratón.

### Lista de comprobación de la documentación

DC | Documentación | Pasa/Falla/No aplicable
DC.1 | Toda la documentación está en un formato accesible, con descripciones textuales alternativas proporcionadas para todas las figuras y diagramas.
DC.2 | La documentación incluye una sección que cubre las características de accesibilidad de la aplicación.

### GOK (Teclado en pantalla de GNOME)

La información de esta página está parcialmente obsoleta: Caribou de GNOME 3 ha reemplazado a gok de GNOME 2.

Su aplicación debería poder usarse a través de gok; las entradas de teclado debería generarlas gok completamente, no el teclado. El objetivo aquí sería trabajar con su aplicación y el escritorio, en general, asegurándose que se puede escribir cualquier carácter de entrada con el teclado en pantalla.

La aplicación gok viene con el Escritorio GNOME, así que debería estar presente. Consulte el sitio oficial de gok para obtener la documentación completa.

Siga estos pasos para comprobar el correcto funcionamiento de gok con su aplicación:

1. Inicie sesión en el Escritorio GNOME

2. Ejecute gok

3. Inicie su aplicación

4. Proporcione entrada a su aplicación con un dispositivo apuntador (ej. un ratón o seguidor de mirada) y gok.

5. Trabaje usando las características de autocompletado y predicción de palabras de gok.

6. Compruebe que gok activa y desactiva los botones de los Menús y Barras de herramientas basadas en la clase de aplicación invocada; por ejemplo, los botones de los Menús y Barras de Herramientas están desactivados para el «capplet» «Propiedades de las tipografías», pero los mismos botones están activados para la aplicación gedit.

7. Compruebe que el teclado en pantalla gok proporciona el botón Redactar y que se puede usar para escribir cualquier texto para la aplicación seleccionada; ejecute gedit, pulse en el área de texto y después pulse el botón Redactar de gok. Seleccione las teclas necesarias en el teclado en pantalla. Los caracteres deberían aparecer en el área de texto de gedit.

8. Compruebe que el botón del Lanzador permite usar el lanzador de cualquiera de las aplicaciones Terminal, Navegador web o Editor de textos.

9. Compruebe que el botón Activar permite al usuario activar cualquiera de las ventanas de las aplicaciones actualmente en ejecución en el escritorio del usuario, incluyendo los paneles de GNOME y el escritorio GNOME.

10. Compruebe que el botón Menús lista todos los menús disponibles en la aplicación actual. Compruebe que al pulsar en el botón de un menú se muestran el submenú y los elementos de menú que contiene el submenú. Finalmente, compruebe que al pulsar en un elemento de menú se activa el elemento del menú. Por ejemplo, pulse en la aplicación Visor de ayuda y pulse el botón Menús. Ahora, la ventana de GOK muestra los botones Archivo, Ir y Ayuda (los menús de Visor de ayuda). Pulse en el botón Archivo y se mostrarán los botones Ventana nueva and Cerrar ventana (elementos del menú).

11. Compruebe que las listas de botones Barras de herramientas listan todos los botones disponibles en la barra de herramientas de la aplicación. Por ejemplo, pulse en la aplicación del Examinador de la ayuda y después pulse en el botón Barras de herramientas. Ahora la ventana de GOK muestra los botones Atrás, Adelante e Inicio.

12. Verifique que el botón Extractor IU muestra todos los objetos de botones para la ventana de la aplicación seleccionada. Por ejemplo, abra la miniaplicación «Propiedades de la tipografía» y pulse el botón Extractor IU en la ventana de GOK. La ventana de GOK debería mostrar los botones de la miniaplicación: Sans, Sans-serif, Cerrar y Ayuda.

### Accerciser

Accerciser y la arquitectura de accesibilidad de GNOME

Accerciser es un examinador interactivo de accesibilidad desarrollado en Python para el Escritorio de GNOME. Usa AT-SPI para inspeccionar y controlar widgets, permitiéndole comprobar si una aplicación está proporcionando información correcta a las tecnologías de asistencia y pruebas automáticas de trabajo. Accerciser tiene un entorno de trabajo de complementos simple que puede usar para crear vistas personalizadas de la información de accesibilidad. Se puede obtener la documentación completa en el Manual oficial de Accerciser. Para ver una demostración de Accerciser y PyATSPI (acceso al entorno del envoltorio de Python y uso de AT-SPI), consulte este artículo. Para una excelente visión general por el autor, consulte el artículo titulado Make Your Application Accessible with Accerciser.

Accerciser ha reemplazado la anterior herramienta at-poke.