gnome-shell/src/st/st-generic-accessible.c

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
 * st-generic-accessible.c: generic accessible
 *
 * Copyright 2013 Igalia, S.L.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU Lesser General Public License,
 * version 2.1, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
 * more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * SECTION:st-generic-accessible
 * @short_description: An accessible class with signals for
 * implementing specific Atk interfaces
 *
 * #StGenericAccessible is mainly a workaround for the current lack of
 * of a proper support for GValue at javascript. See bug#703412 for
 * more information. We implement the accessible interfaces, but proxy
 * the virtual functions into signals, which gjs can catch.
 *
 * #StGenericAccessible is an #StWidgetAccessible
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "st-generic-accessible.h"

static void atk_value_iface_init (AtkValueIface *iface);

G_DEFINE_TYPE_WITH_CODE(StGenericAccessible,
                        st_generic_accessible,
                        ST_TYPE_WIDGET_ACCESSIBLE,
                        G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE,
                                               atk_value_iface_init));
/* Signals */
enum
{
  GET_CURRENT_VALUE,
  GET_MAXIMUM_VALUE,
  GET_MINIMUM_VALUE,
  SET_CURRENT_VALUE,
  GET_MINIMUM_INCREMENT,
  LAST_SIGNAL
};

static guint st_generic_accessible_signals [LAST_SIGNAL] = { 0 };

static void
st_generic_accessible_init (StGenericAccessible *accessible)
{
}

static void
st_generic_accessible_class_init (StGenericAccessibleClass *klass)
{
  /**
   * StGenericAccessible::get-current-value:
   * @self: the #StGenericAccessible
   *
   * Emitted when atk_value_get_current_value() is called on
   * @self. Right now we only care about doubles, so the value is
   * directly returned by the signal.
   *
   * Return value: value of the current element.
   */
  st_generic_accessible_signals[GET_CURRENT_VALUE] =
    g_signal_new ("get-current-value",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL, NULL,
                  G_TYPE_DOUBLE, 0);

  /**
   * StGenericAccessible::get-maximum-value:
   * @self: the #StGenericAccessible
   *
   * Emitted when atk_value_get_maximum_value() is called on
   * @self. Right now we only care about doubles, so the value is
   * directly returned by the signal.
   *
   * Return value: maximum value of the accessible.
   */
  st_generic_accessible_signals[GET_MAXIMUM_VALUE] =
    g_signal_new ("get-maximum-value",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL, NULL,
                  G_TYPE_DOUBLE, 0);

  /**
   * StGenericAccessible::get-minimum-value:
   * @self: the #StGenericAccessible
   *
   * Emitted when atk_value_get_current_value() is called on
   * @self. Right now we only care about doubles, so the value is
   * directly returned by the signal.
   *
   * Return value: minimum value of the accessible.
   */
  st_generic_accessible_signals[GET_MINIMUM_VALUE] =
    g_signal_new ("get-minimum-value",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL, NULL,
                  G_TYPE_DOUBLE, 0);

  /**
   * StGenericAccessible::get-minimum-increment:
   * @self: the #StGenericAccessible
   *
   * Emitted when atk_value_get_minimum_increment() is called on
   * @self. Right now we only care about doubles, so the value is
   * directly returned by the signal.
   *
   * Return value: value of the current element.
   */
  st_generic_accessible_signals[GET_MINIMUM_INCREMENT] =
    g_signal_new ("get-minimum-increment",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL, NULL,
                  G_TYPE_DOUBLE, 0);

  /**
   * StGenericAccessible::set-current-value:
   * @self: the #StGenericAccessible
   * @new_value: the new value for the accessible
   *
   * Emitted when atk_value_set_current_value() is called on
   * @self. Right now we only care about doubles, so the value is
   * directly returned by the signal.
   *
   * Return value: value of the current element.
   */
  st_generic_accessible_signals[SET_CURRENT_VALUE] =
    g_signal_new ("set-current-value",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 1, G_TYPE_DOUBLE);

}

static void
st_generic_accessible_get_current_value (AtkValue *obj,
                                         GValue   *value)
{
  gdouble current_value = 0;

  g_value_init (value, G_TYPE_DOUBLE);
  g_signal_emit (G_OBJECT (obj), st_generic_accessible_signals[GET_CURRENT_VALUE], 0, &current_value);
  g_value_set_double (value, current_value);
}

static void
st_generic_accessible_get_maximum_value (AtkValue *obj,
                                         GValue   *value)
{
  gdouble current_value = 0;

  g_value_init (value, G_TYPE_DOUBLE);
  g_signal_emit (G_OBJECT (obj), st_generic_accessible_signals[GET_MAXIMUM_VALUE], 0, &current_value);
  g_value_set_double (value, current_value);
}

static void
st_generic_accessible_get_minimum_value (AtkValue *obj,
                                         GValue   *value)
{
  gdouble current_value = 0;

  g_value_init (value, G_TYPE_DOUBLE);
  g_signal_emit (G_OBJECT (obj), st_generic_accessible_signals[GET_MINIMUM_VALUE], 0, &current_value);
  g_value_set_double (value, current_value);
}

static void
st_generic_accessible_get_minimum_increment (AtkValue *obj,
                                             GValue   *value)
{
  gdouble current_value = 0;

  g_value_init (value, G_TYPE_DOUBLE);
  g_signal_emit (G_OBJECT (obj), st_generic_accessible_signals[GET_MINIMUM_INCREMENT], 0, &current_value);
  g_value_set_double (value, current_value);
}

static gboolean
st_generic_accessible_set_current_value (AtkValue *obj,
                                         const GValue *value)
{
  gdouble current_value = 0;

  current_value = g_value_get_double (value);
  g_signal_emit (G_OBJECT (obj), st_generic_accessible_signals[SET_CURRENT_VALUE], 0, current_value);

  return TRUE; // we assume that the value was properly set
}

static void
atk_value_iface_init (AtkValueIface *iface)
{
  iface->get_current_value = st_generic_accessible_get_current_value;
  iface->get_maximum_value = st_generic_accessible_get_maximum_value;
  iface->get_minimum_value = st_generic_accessible_get_minimum_value;
  iface->get_minimum_increment = st_generic_accessible_get_minimum_increment;
  iface->set_current_value = st_generic_accessible_set_current_value;
}

AtkObject*
st_generic_accessible_new_for_actor (ClutterActor *actor)
{
  AtkObject *accessible = NULL;

  g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), NULL);

  accessible = ATK_OBJECT (g_object_new (ST_TYPE_GENERIC_ACCESSIBLE,
                                         NULL));
  atk_object_initialize (accessible, actor);

  return accessible;
}