Pileus Git - ~andy/gtk/blob - gtk/gtkaccessible.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright 2001 Sun Microsystems Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21 #include <string.h>
  22
  23 #include "gtkwidget.h"
  24 #include "gtkintl.h"
  25 #include "gtkaccessible.h"
  26
  27 /**
  28  * SECTION:gtkaccessible
  29  * @Short_description: Accessibility support for widgets
  30  * @Title: GtkAccessible
  31  *
  32  * The #GtkAccessible class is the base class for accessible
  33  * implementations for #GtkWidget subclasses. It is a thin
  34  * wrapper around #AtkObject, which adds facilities for associating
  35  * a widget with its accessible object.
  36  *
  37  * An accessible implementation for a third-party widget should
  38  * derive from #GtkAccessible and implement the suitable interfaces
  39  * from ATK, such as #AtkText or #AtkSelection. To establish
  40  * the connection between the widget class and its corresponding
  41  * acccessible implementation, override the get_accessible vfunc
  42  * in #GtkWidgetClass.
  43  */
  44
  45 struct _GtkAccessiblePrivate
  46 {
  47   GtkWidget *widget;
  48 };
  49
  50 enum {
  51   PROP_0,
  52   PROP_WIDGET
  53 };
  54
  55 static void gtk_accessible_real_connect_widget_destroyed (GtkAccessible *accessible);
  56
  57 G_DEFINE_TYPE (GtkAccessible, gtk_accessible, ATK_TYPE_OBJECT)
  58
  59 static void
  60 gtk_accessible_set_property (GObject      *object,
  61                              guint         prop_id,
  62                              const GValue *value,
  63                              GParamSpec   *pspec)
  64 {
  65   GtkAccessible *accessible = GTK_ACCESSIBLE (object);
  66
  67   switch (prop_id)
  68     {
  69     case PROP_WIDGET:
  70       gtk_accessible_set_widget (accessible, g_value_get_object (value));
  71       break;
  72     default:
  73       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  74       break;
  75     }
  76 }
  77
  78 static void
  79 gtk_accessible_get_property (GObject    *object,
  80                              guint       prop_id,
  81                              GValue     *value,
  82                              GParamSpec *pspec)
  83 {
  84   GtkAccessible *accessible = GTK_ACCESSIBLE (object);
  85   GtkAccessiblePrivate *priv = accessible->priv;
  86
  87   switch (prop_id)
  88     {
  89     case PROP_WIDGET:
  90       g_value_set_object (value, priv->widget);
  91       break;
  92     default:
  93       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  94       break;
  95     }
  96 }
  97
  98 static void
  99 gtk_accessible_init (GtkAccessible *accessible)
 100 {
 101   accessible->priv = G_TYPE_INSTANCE_GET_PRIVATE (accessible,
 102                                                   GTK_TYPE_ACCESSIBLE,
 103                                                   GtkAccessiblePrivate);
 104 }
 105
 106 static AtkStateSet *
 107 gtk_accessible_ref_state_set (AtkObject *object)
 108 {
 109   GtkAccessible *accessible = GTK_ACCESSIBLE (object);
 110   AtkStateSet *state_set;
 111
 112   state_set = ATK_OBJECT_CLASS (gtk_accessible_parent_class)->ref_state_set (object);
 113
 114   if (accessible->priv->widget == NULL)
 115     atk_state_set_add_state (state_set, ATK_STATE_DEFUNCT);
 116
 117   return state_set;
 118 }
 119
 120 static void
 121 gtk_accessible_real_widget_set (GtkAccessible *accessible)
 122 {
 123   atk_object_notify_state_change (ATK_OBJECT (accessible), ATK_STATE_DEFUNCT, FALSE);
 124 }
 125
 126 static void
 127 gtk_accessible_real_widget_unset (GtkAccessible *accessible)
 128 {
 129   atk_object_notify_state_change (ATK_OBJECT (accessible), ATK_STATE_DEFUNCT, TRUE);
 130 }
 131
 132 static void
 133 gtk_accessible_class_init (GtkAccessibleClass *klass)
 134 {
 135   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 136   AtkObjectClass *atkobject_class = ATK_OBJECT_CLASS (klass);
 137
 138   klass->connect_widget_destroyed = gtk_accessible_real_connect_widget_destroyed;
 139   klass->widget_set = gtk_accessible_real_widget_set;
 140   klass->widget_unset = gtk_accessible_real_widget_unset;
 141
 142   atkobject_class->ref_state_set = gtk_accessible_ref_state_set;
 143   gobject_class->get_property = gtk_accessible_get_property;
 144   gobject_class->set_property = gtk_accessible_set_property;
 145
 146   g_object_class_install_property (gobject_class,
 147                                    PROP_WIDGET,
 148                                    g_param_spec_object ("widget",
 149                                                         P_("Widget"),
 150                                                         P_("The widget referenced by this accessible."),
 151                                                         GTK_TYPE_WIDGET,
 152                                                         G_PARAM_READWRITE));
 153
 154   g_type_class_add_private (klass, sizeof (GtkAccessiblePrivate));
 155 }
 156
 157 /**
 158  * gtk_accessible_set_widget:
 159  * @accessible: a #GtkAccessible
 160  * @widget: (allow-none): a #GtkWidget or %NULL to unset
 161  *
 162  * Sets the #GtkWidget corresponding to the #GtkAccessible.
 163  *
 164  * <note><para>@accessible will not hold a reference to @widget.
 165  * It is the caller's responsibility to ensure that when @widget
 166  * is destroyed, the widget is unset by calling this function
 167  * again with @widget set to %NULL.</para></note>
 168  * Since: 2.22
 169  */
 170 void
 171 gtk_accessible_set_widget (GtkAccessible *accessible,
 172                            GtkWidget     *widget)
 173 {
 174   GtkAccessiblePrivate *priv;
 175   GtkAccessibleClass *klass;
 176
 177   g_return_if_fail (GTK_IS_ACCESSIBLE (accessible));
 178
 179   priv = accessible->priv;
 180   klass = GTK_ACCESSIBLE_GET_CLASS (accessible);
 181
 182   if (priv->widget == widget)
 183     return;
 184
 185   if (priv->widget)
 186     klass->widget_unset (accessible);
 187
 188   priv->widget = widget;
 189
 190   if (widget);
 191     klass->widget_set (accessible);
 192
 193   g_object_notify (G_OBJECT (accessible), "widget");
 194 }
 195
 196 /**
 197  * gtk_accessible_get_widget:
 198  * @accessible: a #GtkAccessible
 199  *
 200  * Gets the #GtkWidget corresponding to the #GtkAccessible.
 201  * The returned widget does not have a reference added, so
 202  * you do not need to unref it.
 203  *
 204  * Returns: (transfer none): pointer to the #GtkWidget
 205  *     corresponding to the #GtkAccessible, or %NULL.
 206  *
 207  * Since: 2.22
 208  */
 209 GtkWidget*
 210 gtk_accessible_get_widget (GtkAccessible *accessible)
 211 {
 212   g_return_val_if_fail (GTK_IS_ACCESSIBLE (accessible), NULL);
 213
 214   return accessible->priv->widget;
 215 }
 216
 217 /**
 218  * gtk_accessible_connect_widget_destroyed:
 219  * @accessible: a #GtkAccessible
 220  *
 221  * This function specifies the callback function to be called
 222  * when the widget corresponding to a GtkAccessible is destroyed.
 223  */
 224 void
 225 gtk_accessible_connect_widget_destroyed (GtkAccessible *accessible)
 226 {
 227   GtkAccessibleClass *class;
 228
 229   g_return_if_fail (GTK_IS_ACCESSIBLE (accessible));
 230
 231   class = GTK_ACCESSIBLE_GET_CLASS (accessible);
 232
 233   if (class->connect_widget_destroyed)
 234     class->connect_widget_destroyed (accessible);
 235 }
 236
 237 static void
 238 gtk_accessible_widget_destroyed (GtkWidget     *widget,
 239                                  GtkAccessible *accessible)
 240 {
 241   gtk_accessible_set_widget (accessible, NULL);
 242 }
 243
 244 static void
 245 gtk_accessible_real_connect_widget_destroyed (GtkAccessible *accessible)
 246 {
 247   GtkAccessiblePrivate *priv = accessible->priv;
 248
 249   if (priv->widget)
 250     g_signal_connect (priv->widget, "destroy",
 251                       G_CALLBACK (gtk_accessible_widget_destroyed), accessible);
 252 }