From 339d3e41b028344e647d7a5795ace4eb53085ddd Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Fri, 3 Apr 2020 15:14:26 -0400 Subject: [PATCH 1/2] Add GtkScrollbarAccessible When GtkScrollbar stopped being a GtkRange, GtkRangeAccessible stopped working for scrollbars. Update a11y tests to match. --- gtk/a11y/gtkscrollbaraccessible.c | 290 ++++++++++++++++++++++++++++++ gtk/a11y/gtkscrollbaraccessible.h | 57 ++++++ gtk/a11y/meson.build | 2 + gtk/gtk-a11y.h | 1 + gtk/gtkscrollbar.c | 4 +- testsuite/a11y/range.txt | 6 +- 6 files changed, 358 insertions(+), 2 deletions(-) create mode 100644 gtk/a11y/gtkscrollbaraccessible.c create mode 100644 gtk/a11y/gtkscrollbaraccessible.h diff --git a/gtk/a11y/gtkscrollbaraccessible.c b/gtk/a11y/gtkscrollbaraccessible.c new file mode 100644 index 0000000000..8a045cc697 --- /dev/null +++ b/gtk/a11y/gtkscrollbaraccessible.c @@ -0,0 +1,290 @@ +/* GTK+ - accessibility implementations + * Copyright 2001, 2002, 2003 Sun Microsystems Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that 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 library. If not, see . + */ + +#include "config.h" + +#include +#include +#include "gtkscrollbaraccessible.h" + +struct _GtkScrollbarAccessiblePrivate +{ + GtkAdjustment *adjustment; +}; + +static void atk_value_interface_init (AtkValueIface *iface); + +G_DEFINE_TYPE_WITH_CODE (GtkScrollbarAccessible, gtk_scrollbar_accessible, GTK_TYPE_WIDGET_ACCESSIBLE, + G_ADD_PRIVATE (GtkScrollbarAccessible) + G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init)) + +static void +gtk_scrollbar_accessible_value_changed (GtkAdjustment *adjustment, + gpointer data) +{ + g_object_notify (G_OBJECT (data), "accessible-value"); +} + +static void +gtk_scrollbar_accessible_widget_set (GtkAccessible *accessible) +{ + GtkScrollbarAccessiblePrivate *priv = GTK_SCROLLBAR_ACCESSIBLE (accessible)->priv; + GtkWidget *scrollbar; + GtkAdjustment *adj; + + scrollbar = gtk_accessible_get_widget (accessible); + adj = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (scrollbar)); + if (adj) + { + priv->adjustment = adj; + g_object_ref (priv->adjustment); + g_signal_connect (priv->adjustment, "value-changed", + G_CALLBACK (gtk_scrollbar_accessible_value_changed), + accessible); + } +} + +static void +gtk_scrollbar_accessible_widget_unset (GtkAccessible *accessible) +{ + GtkScrollbarAccessiblePrivate *priv = GTK_SCROLLBAR_ACCESSIBLE (accessible)->priv; + + if (priv->adjustment) + { + g_signal_handlers_disconnect_by_func (priv->adjustment, + G_CALLBACK (gtk_scrollbar_accessible_value_changed), + accessible); + g_object_unref (priv->adjustment); + priv->adjustment = NULL; + } +} + +static void +gtk_scrollbar_accessible_initialize (AtkObject *obj, + gpointer data) +{ + ATK_OBJECT_CLASS (gtk_scrollbar_accessible_parent_class)->initialize (obj, data); + obj->role = ATK_ROLE_SCROLL_BAR; +} + +static void +gtk_scrollbar_accessible_notify_gtk (GObject *obj, + GParamSpec *pspec) +{ + GtkWidget *widget = GTK_WIDGET (obj); + AtkObject *scrollbar; + + if (strcmp (pspec->name, "adjustment") == 0) + { + scrollbar = gtk_widget_get_accessible (widget); + gtk_scrollbar_accessible_widget_unset (GTK_ACCESSIBLE (scrollbar)); + gtk_scrollbar_accessible_widget_set (GTK_ACCESSIBLE (scrollbar)); + } + else + GTK_WIDGET_ACCESSIBLE_CLASS (gtk_scrollbar_accessible_parent_class)->notify_gtk (obj, pspec); +} + + +static void +gtk_scrollbar_accessible_class_init (GtkScrollbarAccessibleClass *klass) +{ + AtkObjectClass *class = ATK_OBJECT_CLASS (klass); + GtkAccessibleClass *accessible_class = (GtkAccessibleClass*)klass; + GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass; + + class->initialize = gtk_scrollbar_accessible_initialize; + + accessible_class->widget_set = gtk_scrollbar_accessible_widget_set; + accessible_class->widget_unset = gtk_scrollbar_accessible_widget_unset; + + widget_class->notify_gtk = gtk_scrollbar_accessible_notify_gtk; +} + +static void +gtk_scrollbar_accessible_init (GtkScrollbarAccessible *scrollbar) +{ + scrollbar->priv = gtk_scrollbar_accessible_get_instance_private (scrollbar); +} + +static void +gtk_scrollbar_accessible_get_current_value (AtkValue *obj, + GValue *value) +{ + GtkWidget *widget; + GtkAdjustment *adjustment; + + widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); + adjustment = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (widget)); + if (adjustment == NULL) + return; + + memset (value, 0, sizeof (GValue)); + g_value_init (value, G_TYPE_DOUBLE); + g_value_set_double (value, gtk_adjustment_get_value (adjustment)); +} + +static void +gtk_scrollbar_accessible_get_maximum_value (AtkValue *obj, + GValue *value) +{ + GtkWidget *widget; + GtkAdjustment *adjustment; + double max; + + widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); + adjustment = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (widget)); + if (adjustment == NULL) + return; + + max = gtk_adjustment_get_upper (adjustment) + - gtk_adjustment_get_page_size (adjustment); + + memset (value, 0, sizeof (GValue)); + g_value_init (value, G_TYPE_DOUBLE); + g_value_set_double (value, max); +} + +static void +gtk_scrollbar_accessible_get_minimum_value (AtkValue *obj, + GValue *value) +{ + GtkWidget *widget; + GtkAdjustment *adjustment; + + widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); + adjustment = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (widget)); + if (adjustment == NULL) + return; + + memset (value, 0, sizeof (GValue)); + g_value_init (value, G_TYPE_DOUBLE); + g_value_set_double (value, gtk_adjustment_get_lower (adjustment)); +} + +static void +gtk_scrollbar_accessible_get_minimum_increment (AtkValue *obj, + GValue *value) +{ + GtkWidget *widget; + GtkAdjustment *adjustment; + + widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); + adjustment = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (widget)); + if (adjustment == NULL) + return; + + memset (value, 0, sizeof (GValue)); + g_value_init (value, G_TYPE_DOUBLE); + g_value_set_double (value, gtk_adjustment_get_minimum_increment (adjustment)); +} + +static gboolean +gtk_scrollbar_accessible_set_current_value (AtkValue *obj, + const GValue *value) +{ + GtkWidget *widget; + GtkAdjustment *adjustment; + + widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); + adjustment = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (widget)); + if (adjustment == NULL) + return FALSE; + + gtk_adjustment_set_value (adjustment, g_value_get_double (value)); + + return TRUE; +} + +static void +gtk_scrollbar_accessible_get_value_and_text (AtkValue *obj, + double *value, + char **text) +{ + GtkWidget *widget; + GtkAdjustment *adjustment; + + widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); + adjustment = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (widget)); + if (adjustment == NULL) + return; + + *value = gtk_adjustment_get_value (adjustment); + *text = NULL; +} + +static AtkRange * +gtk_scrollbar_accessible_get_range (AtkValue *obj) +{ + GtkWidget *widget; + GtkAdjustment *adjustment; + double min, max; + + widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); + adjustment = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (widget)); + if (adjustment == NULL) + return NULL; + + min = gtk_adjustment_get_lower (adjustment); + max = gtk_adjustment_get_upper (adjustment) + - gtk_adjustment_get_page_size (adjustment); + + return atk_range_new (min, max, NULL); +} + +static void +gtk_scrollbar_accessible_set_value (AtkValue *obj, + const double value) +{ + GtkWidget *widget; + GtkAdjustment *adjustment; + + widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); + adjustment = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (widget)); + if (adjustment == NULL) + return; + + gtk_adjustment_set_value (adjustment, value); +} + +static double +gtk_scrollbar_accessible_get_increment (AtkValue *obj) +{ + GtkWidget *widget; + GtkAdjustment *adjustment; + + widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); + adjustment = gtk_scrollbar_get_adjustment (GTK_SCROLLBAR (widget)); + if (adjustment == NULL) + return 0; + + return gtk_adjustment_get_minimum_increment (adjustment); +} + +static void +atk_value_interface_init (AtkValueIface *iface) +{ + iface->get_current_value = gtk_scrollbar_accessible_get_current_value; + iface->get_maximum_value = gtk_scrollbar_accessible_get_maximum_value; + iface->get_minimum_value = gtk_scrollbar_accessible_get_minimum_value; + iface->get_minimum_increment = gtk_scrollbar_accessible_get_minimum_increment; + iface->set_current_value = gtk_scrollbar_accessible_set_current_value; + + iface->get_value_and_text = gtk_scrollbar_accessible_get_value_and_text; + iface->get_range = gtk_scrollbar_accessible_get_range; + iface->set_value = gtk_scrollbar_accessible_set_value; + iface->get_increment = gtk_scrollbar_accessible_get_increment; +} diff --git a/gtk/a11y/gtkscrollbaraccessible.h b/gtk/a11y/gtkscrollbaraccessible.h new file mode 100644 index 0000000000..93515bc856 --- /dev/null +++ b/gtk/a11y/gtkscrollbaraccessible.h @@ -0,0 +1,57 @@ +/* GTK+ - accessibility implementations + * Copyright 2001 Sun Microsystems Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library. If not, see . + */ + +#ifndef __GTK_SCROLLBAR_ACCESSIBLE_H__ +#define __GTK_SCROLLBAR_ACCESSIBLE_H__ + +#if !defined (__GTK_A11Y_H_INSIDE__) && !defined (GTK_COMPILATION) +#error "Only can be included directly." +#endif + +#include + +G_BEGIN_DECLS + +#define GTK_TYPE_SCROLLBAR_ACCESSIBLE (gtk_scrollbar_accessible_get_type ()) +#define GTK_SCROLLBAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLBAR_ACCESSIBLE, GtkScrollbarAccessible)) +#define GTK_SCROLLBAR_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLBAR_ACCESSIBLE, GtkScrollbarAccessibleClass)) +#define GTK_IS_SCROLLBAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLBAR_ACCESSIBLE)) +#define GTK_IS_SCROLLBAR_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCROLLBAR_ACCESSIBLE)) +#define GTK_SCROLLBAR_ACCESSIBLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCROLLBAR_ACCESSIBLE, GtkScrollbarAccessibleClass)) + +typedef struct _GtkScrollbarAccessible GtkScrollbarAccessible; +typedef struct _GtkScrollbarAccessibleClass GtkScrollbarAccessibleClass; +typedef struct _GtkScrollbarAccessiblePrivate GtkScrollbarAccessiblePrivate; + +struct _GtkScrollbarAccessible +{ + GtkWidgetAccessible parent; + + GtkScrollbarAccessiblePrivate *priv; +}; + +struct _GtkScrollbarAccessibleClass +{ + GtkWidgetAccessibleClass parent_class; +}; + +GDK_AVAILABLE_IN_ALL +GType gtk_scrollbar_accessible_get_type (void); + +G_END_DECLS + +#endif /* __GTK_SCROLLBAR_ACCESSIBLE_H__ */ diff --git a/gtk/a11y/meson.build b/gtk/a11y/meson.build index d8f330e016..bece44428f 100644 --- a/gtk/a11y/meson.build +++ b/gtk/a11y/meson.build @@ -36,6 +36,7 @@ a11y_sources = files([ 'gtkrenderercellaccessible.c', 'gtkscaleaccessible.c', 'gtkscalebuttonaccessible.c', + 'gtkscrollbaraccessible.c', 'gtkscrolledwindowaccessible.c', 'gtkspinbuttonaccessible.c', 'gtkspinneraccessible.c', @@ -87,6 +88,7 @@ a11y_headers = files([ 'gtkrenderercellaccessible.h', 'gtkscaleaccessible.h', 'gtkscalebuttonaccessible.h', + 'gtkscrollbaraccessible.h', 'gtkscrolledwindowaccessible.h', 'gtkspinbuttonaccessible.h', 'gtkspinneraccessible.h', diff --git a/gtk/gtk-a11y.h b/gtk/gtk-a11y.h index 05a0cb21bc..24fe4dd4ee 100644 --- a/gtk/gtk-a11y.h +++ b/gtk/gtk-a11y.h @@ -62,6 +62,7 @@ #include #include #include +#include #include #include #include diff --git a/gtk/gtkscrollbar.c b/gtk/gtkscrollbar.c index f97d3d7647..97730e1eea 100644 --- a/gtk/gtkscrollbar.c +++ b/gtk/gtkscrollbar.c @@ -35,6 +35,8 @@ #include "gtkprivate.h" #include "gtkboxlayout.h" +#include "a11y/gtkscrollbaraccessible.h" + /** * SECTION:gtkscrollbar @@ -204,7 +206,7 @@ gtk_scrollbar_class_init (GtkScrollbarClass *class) g_object_class_override_property (object_class, PROP_ORIENTATION, "orientation"); - gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_SCROLL_BAR); + gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_SCROLLBAR_ACCESSIBLE); gtk_widget_class_set_css_name (widget_class, I_("scrollbar")); gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BOX_LAYOUT); } diff --git a/testsuite/a11y/range.txt b/testsuite/a11y/range.txt index 558ff28411..e9a61543e0 100644 --- a/testsuite/a11y/range.txt +++ b/testsuite/a11y/range.txt @@ -41,8 +41,12 @@ window1 "scroll bar" parent: grid1 index: 1 - state: enabled horizontal sensitive showing visible + state: enabled focusable horizontal sensitive showing visible toolkit: gtk layer: widget alpha: 1 + + minimum value: 0.500000 + maximum value: 99.500000 + current value: 45.500000 From 5205fa0ff7635154a76e7c810bfc00cf041029ca Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Fri, 3 Apr 2020 23:31:45 -0400 Subject: [PATCH 2/2] scrollbar: Be more defensive Somehow the scrollbar accessible manages to call gtk_scrollbar_get_adjustment when priv->range is NULL. Survive taht. --- gtk/gtkscrollbar.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/gtk/gtkscrollbar.c b/gtk/gtkscrollbar.c index 97730e1eea..84b18c02dc 100644 --- a/gtk/gtkscrollbar.c +++ b/gtk/gtkscrollbar.c @@ -285,5 +285,8 @@ gtk_scrollbar_get_adjustment (GtkScrollbar *self) g_return_val_if_fail (GTK_IS_SCROLLBAR (self), NULL); - return gtk_range_get_adjustment (GTK_RANGE (priv->range)); + if (priv->range) + return gtk_range_get_adjustment (GTK_RANGE (priv->range)); + + return NULL; }