path: root/accessible/atk/UtilInterface.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "ApplicationAccessibleWrap.h"
#include "mozilla/Likely.h"
#include "nsAccessibilityService.h"
#include "nsMai.h"

#include <atk/atk.h>
#include <gtk/gtk.h>
#include <string.h>

using namespace mozilla;
using namespace mozilla::a11y;

typedef AtkUtil MaiUtil;
typedef AtkUtilClass MaiUtilClass;

#define MAI_VERSION MOZILLA_VERSION
#define MAI_NAME "Gecko"

extern "C" {
static guint (*gail_add_global_event_listener)(GSignalEmissionHook listener,
                                               const gchar* event_type);
static void (*gail_remove_global_event_listener)(guint remove_listener);
static void (*gail_remove_key_event_listener)(guint remove_listener);
static AtkObject* (*gail_get_root)();
}

struct MaiUtilListenerInfo {
  gint key;
  guint signal_id;
  gulong hook_id;
  // For window create/destory/minimize/maximize/restore/activate/deactivate
  // events, we'll chain gail_util's add/remove_global_event_listener.
  // So we store the listenerid returned by gail's add_global_event_listener
  // in this structure to call gail's remove_global_event_listener later.
  guint gail_listenerid;
};

static GHashTable* sListener_list = nullptr;
static gint sListener_idx = 1;

extern "C" {
static guint add_listener(GSignalEmissionHook listener,
                          const gchar* object_type, const gchar* signal,
                          const gchar* hook_data, guint gail_listenerid = 0) {
  GType type;
  guint signal_id;
  gint rc = 0;

  type = g_type_from_name(object_type);
  if (type) {
    signal_id = g_signal_lookup(signal, type);
    if (signal_id > 0) {
      MaiUtilListenerInfo* listener_info;

      rc = sListener_idx;

      listener_info =
          (MaiUtilListenerInfo*)g_malloc(sizeof(MaiUtilListenerInfo));
      listener_info->key = sListener_idx;
      listener_info->hook_id = g_signal_add_emission_hook(
          signal_id, 0, listener, g_strdup(hook_data), (GDestroyNotify)g_free);
      listener_info->signal_id = signal_id;
      listener_info->gail_listenerid = gail_listenerid;

      g_hash_table_insert(sListener_list, &(listener_info->key), listener_info);
      sListener_idx++;
    } else {
      g_warning("Invalid signal type %s\n", signal);
    }
  } else {
    g_warning("Invalid object type %s\n", object_type);
  }
  return rc;
}

static guint mai_util_add_global_event_listener(GSignalEmissionHook listener,
                                                const gchar* event_type) {
  guint rc = 0;
  gchar** split_string;

  split_string = g_strsplit(event_type, ":", 3);

  if (split_string) {
    if (!strcmp("window", split_string[0])) {
      guint gail_listenerid = 0;
      if (gail_add_global_event_listener) {
        // call gail's function to track gtk native window events
        gail_listenerid = gail_add_global_event_listener(listener, event_type);
      }

      rc = add_listener(listener, "MaiAtkObject", split_string[1], event_type,
                        gail_listenerid);
    } else {
      rc = add_listener(listener, split_string[1], split_string[2], event_type);
    }
    g_strfreev(split_string);
  }
  return rc;
}

static void mai_util_remove_global_event_listener(guint remove_listener) {
  if (remove_listener > 0) {
    MaiUtilListenerInfo* listener_info;
    gint tmp_idx = remove_listener;

    listener_info =
        (MaiUtilListenerInfo*)g_hash_table_lookup(sListener_list, &tmp_idx);

    if (listener_info != nullptr) {
      if (gail_remove_global_event_listener && listener_info->gail_listenerid) {
        gail_remove_global_event_listener(listener_info->gail_listenerid);
      }

      /* Hook id of 0 and signal id of 0 are invalid */
      if (listener_info->hook_id != 0 && listener_info->signal_id != 0) {
        /* Remove the emission hook */
        g_signal_remove_emission_hook(listener_info->signal_id,
                                      listener_info->hook_id);

        /* Remove the element from the hash */
        g_hash_table_remove(sListener_list, &tmp_idx);
      } else {
        g_warning("Invalid listener hook_id %ld or signal_id %d\n",
                  listener_info->hook_id, listener_info->signal_id);
      }
    } else {
      // atk-bridge is initialized with gail (e.g. yelp)
      // try gail_remove_global_event_listener
      if (gail_remove_global_event_listener) {
        return gail_remove_global_event_listener(remove_listener);
      }

      g_warning("No listener with the specified listener id %d",
                remove_listener);
    }
  } else {
    g_warning("Invalid listener_id %d", remove_listener);
  }
}

static AtkKeyEventStruct* atk_key_event_from_gdk_event_key(GdkEventKey* key) {
  AtkKeyEventStruct* event = g_new0(AtkKeyEventStruct, 1);
  switch (key->type) {
    case GDK_KEY_PRESS:
      event->type = ATK_KEY_EVENT_PRESS;
      break;
    case GDK_KEY_RELEASE:
      event->type = ATK_KEY_EVENT_RELEASE;
      break;
    default:
      g_assert_not_reached();
      return nullptr;
  }
  event->state = key->state;
  event->keyval = key->keyval;
  event->length = key->length;
  if (key->string && key->string[0] &&
      g_unichar_isgraph(g_utf8_get_char(key->string))) {
    event->string = key->string;
  } else if (key->type == GDK_KEY_PRESS || key->type == GDK_KEY_RELEASE) {
    event->string = gdk_keyval_name(key->keyval);
  }
  event->keycode = key->hardware_keycode;
  event->timestamp = key->time;

  return event;
}

struct MaiKeyEventInfo {
  AtkKeyEventStruct* key_event;
  gpointer func_data;
};

union AtkKeySnoopFuncPointer {
  AtkKeySnoopFunc func_ptr;
  gpointer data;
};

static gboolean notify_hf(gpointer key, gpointer value, gpointer data) {
  MaiKeyEventInfo* info = (MaiKeyEventInfo*)data;
  AtkKeySnoopFuncPointer atkKeySnoop;
  atkKeySnoop.data = value;
  return (atkKeySnoop.func_ptr)(info->key_event, info->func_data) ? TRUE
                                                                  : FALSE;
}

static void insert_hf(gpointer key, gpointer value, gpointer data) {
  GHashTable* new_table = (GHashTable*)data;
  g_hash_table_insert(new_table, key, value);
}

static GHashTable* sKey_listener_list = nullptr;

static gint mai_key_snooper(GtkWidget* the_widget, GdkEventKey* event,
                            gpointer func_data) {
  /* notify each AtkKeySnoopFunc in turn... */

  MaiKeyEventInfo* info = g_new0(MaiKeyEventInfo, 1);
  gint consumed = 0;
  if (sKey_listener_list) {
    GHashTable* new_hash = g_hash_table_new(nullptr, nullptr);
    g_hash_table_foreach(sKey_listener_list, insert_hf, new_hash);
    info->key_event = atk_key_event_from_gdk_event_key(event);
    info->func_data = func_data;
    consumed = g_hash_table_foreach_steal(new_hash, notify_hf, info);
    g_hash_table_destroy(new_hash);
    g_free(info->key_event);
  }
  g_free(info);
  return (consumed ? 1 : 0);
}

static guint sKey_snooper_id = 0;

static guint mai_util_add_key_event_listener(AtkKeySnoopFunc listener,
                                             gpointer data) {
  if (MOZ_UNLIKELY(!listener)) {
    return 0;
  }

  static guint key = 0;

  if (!sKey_listener_list) {
    sKey_listener_list = g_hash_table_new(nullptr, nullptr);
  }

  // If we have no registered event listeners then we need to (re)install the
  // key event snooper.
  if (g_hash_table_size(sKey_listener_list) == 0) {
    sKey_snooper_id = gtk_key_snooper_install(mai_key_snooper, data);
  }

  AtkKeySnoopFuncPointer atkKeySnoop;
  atkKeySnoop.func_ptr = listener;
  key++;
  g_hash_table_insert(sKey_listener_list, GUINT_TO_POINTER(key),
                      atkKeySnoop.data);
  return key;
}

static void mai_util_remove_key_event_listener(guint remove_listener) {
  if (!sKey_listener_list) {
    // atk-bridge is initialized with gail (e.g. yelp)
    // try gail_remove_key_event_listener
    return gail_remove_key_event_listener(remove_listener);
  }

  g_hash_table_remove(sKey_listener_list, GUINT_TO_POINTER(remove_listener));
  if (g_hash_table_size(sKey_listener_list) == 0) {
    gtk_key_snooper_remove(sKey_snooper_id);
  }
}

static AtkObject* mai_util_get_root() {
  ApplicationAccessible* app = ApplicationAcc();
  if (app) return app->GetAtkObject();

  // We've shutdown, try to use gail instead
  // (to avoid assert in spi_atk_tidy_windows())
  // XXX tbsaunde then why didn't we replace the gail atk_util impl?
  if (gail_get_root) return gail_get_root();

  return nullptr;
}

static const gchar* mai_util_get_toolkit_name() { return MAI_NAME; }

static const gchar* mai_util_get_toolkit_version() { return MAI_VERSION; }

static void _listener_info_destroy(gpointer data) { g_free(data); }

static void window_added(AtkObject* atk_obj, guint index, AtkObject* child) {
  if (!IS_MAI_OBJECT(child)) return;

  static guint id = g_signal_lookup("create", MAI_TYPE_ATK_OBJECT);
  g_signal_emit(child, id, 0);
}

static void window_removed(AtkObject* atk_obj, guint index, AtkObject* child) {
  if (!IS_MAI_OBJECT(child)) return;

  static guint id = g_signal_lookup("destroy", MAI_TYPE_ATK_OBJECT);
  g_signal_emit(child, id, 0);
}

static void UtilInterfaceInit(MaiUtilClass* klass) {
  AtkUtilClass* atk_class;
  gpointer data;

  data = g_type_class_peek(ATK_TYPE_UTIL);
  atk_class = ATK_UTIL_CLASS(data);

  // save gail function pointer
  gail_add_global_event_listener = atk_class->add_global_event_listener;
  gail_remove_global_event_listener = atk_class->remove_global_event_listener;
  gail_remove_key_event_listener = atk_class->remove_key_event_listener;
  gail_get_root = atk_class->get_root;

  atk_class->add_global_event_listener = mai_util_add_global_event_listener;
  atk_class->remove_global_event_listener =
      mai_util_remove_global_event_listener;
  atk_class->add_key_event_listener = mai_util_add_key_event_listener;
  atk_class->remove_key_event_listener = mai_util_remove_key_event_listener;
  atk_class->get_root = mai_util_get_root;
  atk_class->get_toolkit_name = mai_util_get_toolkit_name;
  atk_class->get_toolkit_version = mai_util_get_toolkit_version;

  sListener_list = g_hash_table_new_full(g_int_hash, g_int_equal, nullptr,
                                         _listener_info_destroy);
  // Keep track of added/removed windows.
  AtkObject* root = atk_get_root();
  g_signal_connect(root, "children-changed::add", (GCallback)window_added,
                   nullptr);
  g_signal_connect(root, "children-changed::remove", (GCallback)window_removed,
                   nullptr);
}
}

GType mai_util_get_type() {
  static GType type = 0;

  if (!type) {
    static const GTypeInfo tinfo = {
        sizeof(MaiUtilClass),
        (GBaseInitFunc) nullptr,           /* base init */
        (GBaseFinalizeFunc) nullptr,       /* base finalize */
        (GClassInitFunc)UtilInterfaceInit, /* class init */
        (GClassFinalizeFunc) nullptr,      /* class finalize */
        nullptr,                           /* class data */
        sizeof(MaiUtil),                   /* instance size */
        0,                                 /* nb preallocs */
        (GInstanceInitFunc) nullptr,       /* instance init */
        nullptr                            /* value table */
    };

    type =
        g_type_register_static(ATK_TYPE_UTIL, "MaiUtil", &tinfo, GTypeFlags(0));
  }
  return type;
}