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