Pileus Git - ~andy/gtk/blob - gtk/a11y/gtkrangeaccessible.c

   1 /* GTK+ - accessibility implementations
   2  * Copyright 2001, 2002, 2003 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, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19
  20 #include <string.h>
  21 #include <gtk/gtk.h>
  22 #include "gtkrangeaccessible.h"
  23
  24
  25 static void atk_value_interface_init  (AtkValueIface  *iface);
  26
  27 G_DEFINE_TYPE_WITH_CODE (GtkRangeAccessible, gtk_range_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
  28                          G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
  29
  30 static void
  31 gtk_range_accessible_value_changed (GtkAdjustment *adjustment,
  32                                     gpointer       data)
  33 {
  34   g_object_notify (G_OBJECT (data), "accessible-value");
  35 }
  36
  37 static void
  38 gtk_range_accessible_initialize (AtkObject *obj,
  39                                  gpointer   data)
  40 {
  41   GtkRangeAccessible *range = GTK_RANGE_ACCESSIBLE (obj);
  42   GtkAdjustment *adj;
  43   GtkRange *gtk_range;
  44
  45   ATK_OBJECT_CLASS (gtk_range_accessible_parent_class)->initialize (obj, data);
  46
  47   gtk_range = GTK_RANGE (data);
  48   /*
  49    * If a GtkAdjustment already exists for the GtkRange,
  50    * create the GailAdjustment
  51    */
  52   adj = gtk_range_get_adjustment (gtk_range);
  53   if (adj)
  54     g_signal_connect (adj, "value-changed",
  55                       G_CALLBACK (gtk_range_accessible_value_changed),
  56                       range);
  57
  58   obj->role = ATK_ROLE_SLIDER;
  59 }
  60
  61 static void
  62 gtk_range_accessible_finalize (GObject *object)
  63 {
  64   GtkRangeAccessible *range = GTK_RANGE_ACCESSIBLE (object);
  65   GtkWidget *widget;
  66   GtkAdjustment *adj;
  67
  68   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (object));
  69   if (widget)
  70     {
  71       adj = gtk_range_get_adjustment (GTK_RANGE (widget));
  72       if (adj)
  73         g_signal_handlers_disconnect_by_func (adj,
  74                                               gtk_range_accessible_value_changed,
  75                                               range);
  76     }
  77
  78   G_OBJECT_CLASS (gtk_range_accessible_parent_class)->finalize (object);
  79 }
  80
  81 static void
  82 gtk_range_accessible_notify_gtk (GObject    *obj,
  83                                  GParamSpec *pspec)
  84 {
  85   GtkWidget *widget = GTK_WIDGET (obj);
  86   GtkAdjustment *adj;
  87   AtkObject *range;
  88
  89   if (strcmp (pspec->name, "adjustment") == 0)
  90     {
  91       range = gtk_widget_get_accessible (widget);
  92       adj = gtk_range_get_adjustment (GTK_RANGE (widget));
  93       g_signal_connect (adj, "value-changed",
  94                         G_CALLBACK (gtk_range_accessible_value_changed),
  95                         range);
  96     }
  97   else
  98     GTK_WIDGET_ACCESSIBLE_CLASS (gtk_range_accessible_parent_class)->notify_gtk (obj, pspec);
  99 }
 100
 101
 102 static void
 103 gtk_range_accessible_class_init (GtkRangeAccessibleClass *klass)
 104 {
 105   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 106   AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
 107   GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
 108
 109   widget_class->notify_gtk = gtk_range_accessible_notify_gtk;
 110
 111   class->initialize = gtk_range_accessible_initialize;
 112
 113   gobject_class->finalize = gtk_range_accessible_finalize;
 114 }
 115
 116 static void
 117 gtk_range_accessible_init (GtkRangeAccessible *range)
 118 {
 119 }
 120
 121 static void
 122 gtk_range_accessible_get_current_value (AtkValue *obj,
 123                                         GValue   *value)
 124 {
 125   GtkWidget *widget;
 126   GtkAdjustment *adjustment;
 127
 128   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 129   adjustment = gtk_range_get_adjustment (GTK_RANGE (widget));
 130   if (adjustment == NULL)
 131     return;
 132
 133   memset (value,  0, sizeof (GValue));
 134   g_value_init (value, G_TYPE_DOUBLE);
 135   g_value_set_double (value, gtk_adjustment_get_value (adjustment));
 136 }
 137
 138 static void
 139 gtk_range_accessible_get_maximum_value (AtkValue *obj,
 140                                         GValue   *value)
 141 {
 142   GtkWidget *widget;
 143   GtkAdjustment *adjustment;
 144   gdouble max;
 145
 146   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 147   adjustment = gtk_range_get_adjustment (GTK_RANGE (widget));
 148   if (adjustment == NULL)
 149     return;
 150
 151   max = gtk_adjustment_get_upper (adjustment)
 152         - gtk_adjustment_get_page_size (adjustment);
 153
 154   if (gtk_range_get_restrict_to_fill_level (GTK_RANGE (widget)))
 155     max = MIN (max, gtk_range_get_fill_level (GTK_RANGE (widget)));
 156
 157   memset (value,  0, sizeof (GValue));
 158   g_value_init (value, G_TYPE_DOUBLE);
 159   g_value_set_double (value, max);
 160 }
 161
 162 static void
 163 gtk_range_accessible_get_minimum_value (AtkValue *obj,
 164                                         GValue   *value)
 165 {
 166   GtkWidget *widget;
 167   GtkAdjustment *adjustment;
 168
 169   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 170   adjustment = gtk_range_get_adjustment (GTK_RANGE (widget));
 171   if (adjustment == NULL)
 172     return;
 173
 174   memset (value,  0, sizeof (GValue));
 175   g_value_init (value, G_TYPE_DOUBLE);
 176   g_value_set_double (value, gtk_adjustment_get_lower (adjustment));
 177 }
 178
 179 static void
 180 gtk_range_accessible_get_minimum_increment (AtkValue *obj,
 181                                             GValue   *value)
 182 {
 183   GtkWidget *widget;
 184   GtkAdjustment *adjustment;
 185
 186   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 187   adjustment = gtk_range_get_adjustment (GTK_RANGE (widget));
 188   if (adjustment == NULL)
 189     return;
 190
 191   memset (value,  0, sizeof (GValue));
 192   g_value_init (value, G_TYPE_DOUBLE);
 193   g_value_set_double (value, gtk_adjustment_get_minimum_increment (adjustment));
 194 }
 195
 196 static gboolean
 197 gtk_range_accessible_set_current_value (AtkValue     *obj,
 198                                         const GValue *value)
 199 {
 200  GtkWidget *widget;
 201   GtkAdjustment *adjustment;
 202
 203   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 204   adjustment = gtk_range_get_adjustment (GTK_RANGE (widget));
 205   if (adjustment == NULL)
 206     return FALSE;
 207
 208   gtk_adjustment_set_value (adjustment, g_value_get_double (value));
 209
 210   return TRUE;
 211 }
 212
 213 static void
 214 atk_value_interface_init (AtkValueIface *iface)
 215 {
 216   iface->get_current_value = gtk_range_accessible_get_current_value;
 217   iface->get_maximum_value = gtk_range_accessible_get_maximum_value;
 218   iface->get_minimum_value = gtk_range_accessible_get_minimum_value;
 219   iface->get_minimum_increment = gtk_range_accessible_get_minimum_increment;
 220   iface->set_current_value = gtk_range_accessible_set_current_value;
 221 }