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 void
 107 gtk_accessible_real_widget_set (GtkAccessible *accessible)
 108 {
 109 }
 110
 111 static void
 112 gtk_accessible_real_widget_unset (GtkAccessible *accessible)
 113 {
 114 }
 115
 116 static void
 117 gtk_accessible_class_init (GtkAccessibleClass *klass)
 118 {
 119   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 120
 121   klass->connect_widget_destroyed = gtk_accessible_real_connect_widget_destroyed;
 122   klass->widget_set = gtk_accessible_real_widget_set;
 123   klass->widget_unset = gtk_accessible_real_widget_unset;
 124
 125   gobject_class->get_property = gtk_accessible_get_property;
 126   gobject_class->set_property = gtk_accessible_set_property;
 127
 128   g_object_class_install_property (gobject_class,
 129                                    PROP_WIDGET,
 130                                    g_param_spec_object ("widget",
 131                                                         P_("Widget"),
 132                                                         P_("The widget referenced by this accessible."),
 133                                                         GTK_TYPE_WIDGET,
 134                                                         G_PARAM_READWRITE));
 135
 136   g_type_class_add_private (klass, sizeof (GtkAccessiblePrivate));
 137 }
 138
 139 /**
 140  * gtk_accessible_set_widget:
 141  * @accessible: a #GtkAccessible
 142  * @widget: (allow-none): a #GtkWidget or %NULL to unset
 143  *
 144  * Sets the #GtkWidget corresponding to the #GtkAccessible.
 145  *
 146  * <note><para>@accessible will not hold a reference to @widget.
 147  * It is the caller's responsibility to ensure that when @widget
 148  * is destroyed, the widget is unset by calling this function
 149  * again with @widget set to %NULL.</para></note>
 150  * Since: 2.22
 151  */
 152 void
 153 gtk_accessible_set_widget (GtkAccessible *accessible,
 154                            GtkWidget     *widget)
 155 {
 156   GtkAccessiblePrivate *priv;
 157   GtkAccessibleClass *klass;
 158
 159   g_return_if_fail (GTK_IS_ACCESSIBLE (accessible));
 160
 161   priv = accessible->priv;
 162   klass = GTK_ACCESSIBLE_GET_CLASS (accessible);
 163
 164   if (priv->widget == widget)
 165     return;
 166
 167   if (priv->widget)
 168     klass->widget_unset (accessible);
 169
 170   priv->widget = widget;
 171
 172   if (widget);
 173     klass->widget_set (accessible);
 174
 175   g_object_notify (G_OBJECT (accessible), "widget");
 176 }
 177
 178 /**
 179  * gtk_accessible_get_widget:
 180  * @accessible: a #GtkAccessible
 181  *
 182  * Gets the #GtkWidget corresponding to the #GtkAccessible.
 183  * The returned widget does not have a reference added, so
 184  * you do not need to unref it.
 185  *
 186  * Returns: (transfer none): pointer to the #GtkWidget
 187  *     corresponding to the #GtkAccessible, or %NULL.
 188  *
 189  * Since: 2.22
 190  */
 191 GtkWidget*
 192 gtk_accessible_get_widget (GtkAccessible *accessible)
 193 {
 194   g_return_val_if_fail (GTK_IS_ACCESSIBLE (accessible), NULL);
 195
 196   return accessible->priv->widget;
 197 }
 198
 199 /**
 200  * gtk_accessible_connect_widget_destroyed:
 201  * @accessible: a #GtkAccessible
 202  *
 203  * This function specifies the callback function to be called
 204  * when the widget corresponding to a GtkAccessible is destroyed.
 205  */
 206 void
 207 gtk_accessible_connect_widget_destroyed (GtkAccessible *accessible)
 208 {
 209   GtkAccessibleClass *class;
 210
 211   g_return_if_fail (GTK_IS_ACCESSIBLE (accessible));
 212
 213   class = GTK_ACCESSIBLE_GET_CLASS (accessible);
 214
 215   if (class->connect_widget_destroyed)
 216     class->connect_widget_destroyed (accessible);
 217 }
 218
 219 static void
 220 gtk_accessible_widget_destroyed (GtkWidget     *widget,
 221                                  GtkAccessible *accessible)
 222 {
 223   gtk_accessible_set_widget (accessible, NULL);
 224 }
 225
 226 static void
 227 gtk_accessible_real_connect_widget_destroyed (GtkAccessible *accessible)
 228 {
 229   GtkAccessiblePrivate *priv = accessible->priv;
 230
 231   if (priv->widget)
 232     g_signal_connect (priv->widget, "destroy",
 233                       G_CALLBACK (gtk_accessible_widget_destroyed), accessible);
 234 }