diff --git a/gtk/gtkaccessible.c b/gtk/gtkaccessible.c index 47bebc7543..0d6e2bd717 100644 --- a/gtk/gtkaccessible.c +++ b/gtk/gtkaccessible.c @@ -116,7 +116,7 @@ gtk_accessible_get_accessible_role (GtkAccessible *self) * state change must be communicated to assistive technologies. */ void -gtk_accessible_update_state (GtkAccessible *self, +gtk_accessible_update_state (GtkAccessible *self, GtkAccessibleState first_state, ...) { @@ -141,13 +141,13 @@ gtk_accessible_update_state (GtkAccessible *self, if (value == NULL) goto out; - gtk_at_context_set_state (context, state, value); + gtk_at_context_set_accessible_state (context, state, value); gtk_accessible_value_unref (value); state = va_arg (args, int); } - gtk_at_context_update_state (context); + gtk_at_context_update (context); out: va_end (args); @@ -185,7 +185,57 @@ gtk_accessible_update_state_value (GtkAccessible *self, if (real_value == NULL) return; - gtk_at_context_set_state (context, state, real_value); + gtk_at_context_set_accessible_state (context, state, real_value); gtk_accessible_value_unref (real_value); - gtk_at_context_update_state (context); + gtk_at_context_update (context); +} + +/** + * gtk_accessible_update_property: + * @self: a #GtkAccessible + * @first_property: the first #GtkAccessibleProperty + * @...: a list of property and value pairs, terminated by -1 + * + * Updates a list of accessible properties. + * + * This function should be called by #GtkWidget types whenever an accessible + * property change must be communicated to assistive technologies. + */ +void +gtk_accessible_update_property (GtkAccessible *self, + GtkAccessibleProperty first_property, + ...) +{ + GtkAccessibleProperty property; + GtkATContext *context; + va_list args; + + g_return_if_fail (GTK_IS_ACCESSIBLE (self)); + + context = gtk_accessible_get_at_context (self); + if (context == NULL) + return; + + va_start (args, first_property); + + property = first_property; + + while (property != -1) + { + GtkAccessibleValue *value = gtk_accessible_value_collect_for_property (property, &args); + + /* gtk_accessible_value_collect_for_property() will warn for us */ + if (value == NULL) + goto out; + + gtk_at_context_set_accessible_property (context, property, value); + gtk_accessible_value_unref (value); + + property = va_arg (args, int); + } + + gtk_at_context_update (context); + +out: + va_end (args); } diff --git a/gtk/gtkaccessible.h b/gtk/gtkaccessible.h index 5b943f89a2..f95ba930d2 100644 --- a/gtk/gtkaccessible.h +++ b/gtk/gtkaccessible.h @@ -32,15 +32,19 @@ GDK_AVAILABLE_IN_ALL G_DECLARE_INTERFACE (GtkAccessible, gtk_accessible, GTK, ACCESSIBLE, GObject) GDK_AVAILABLE_IN_ALL -GtkAccessibleRole gtk_accessible_get_accessible_role (GtkAccessible *self); +GtkAccessibleRole gtk_accessible_get_accessible_role (GtkAccessible *self); GDK_AVAILABLE_IN_ALL -void gtk_accessible_update_state (GtkAccessible *self, - GtkAccessibleState first_state, +void gtk_accessible_update_state (GtkAccessible *self, + GtkAccessibleState first_state, ...); GDK_AVAILABLE_IN_ALL -void gtk_accessible_update_state_value (GtkAccessible *self, - GtkAccessibleState state, - const GValue *value); +void gtk_accessible_update_property (GtkAccessible *self, + GtkAccessibleProperty first_property, + ...); +GDK_AVAILABLE_IN_ALL +void gtk_accessible_update_state_value (GtkAccessible *self, + GtkAccessibleState state, + const GValue *value); G_END_DECLS diff --git a/gtk/gtkaccessiblevalue.c b/gtk/gtkaccessiblevalue.c index 2fd6f76742..9394738c8e 100644 --- a/gtk/gtkaccessiblevalue.c +++ b/gtk/gtkaccessiblevalue.c @@ -44,6 +44,7 @@ #include "gtkaccessiblevalueprivate.h" +#include "gtkaccessible.h" #include "gtkenums.h" G_DEFINE_QUARK (gtk-accessible-value-error-quark, gtk_accessible_value_error) @@ -368,6 +369,92 @@ gtk_string_accessible_value_get (const GtkAccessibleValue *value) return self->value; } +typedef struct { + GtkAccessibleValue parent; + + GtkAccessible *ref; +} GtkReferenceAccessibleValue; + +static void +remove_weak_ref (gpointer data, + GObject *old_reference) +{ + GtkReferenceAccessibleValue *self = data; + + self->ref = NULL; +} + +static void +gtk_reference_accessible_value_finalize (GtkAccessibleValue *value) +{ + GtkReferenceAccessibleValue *self = (GtkReferenceAccessibleValue *) value; + + if (self->ref != NULL) + g_object_weak_unref (G_OBJECT (self->ref), remove_weak_ref, self); +} + +static gboolean +gtk_reference_accessible_value_equal (const GtkAccessibleValue *value_a, + const GtkAccessibleValue *value_b) +{ + const GtkReferenceAccessibleValue *self_a = (GtkReferenceAccessibleValue *) value_a; + const GtkReferenceAccessibleValue *self_b = (GtkReferenceAccessibleValue *) value_b; + + return self_a->ref == self_b->ref; +} + +static void +gtk_reference_accessible_value_print (const GtkAccessibleValue *value, + GString *buffer) +{ + const GtkReferenceAccessibleValue *self = (GtkReferenceAccessibleValue *) value; + + if (self->ref != NULL) + { + g_string_append_printf (buffer, "%s<%p>", + G_OBJECT_TYPE_NAME (self->ref), + self->ref); + } + else + { + g_string_append (buffer, ""); + } +} + +static const GtkAccessibleValueClass GTK_REFERENCE_ACCESSIBLE_VALUE = { + .type_name = "GtkReferenceAccessibleValue", + .instance_size = sizeof (GtkReferenceAccessibleValue), + .finalize = gtk_reference_accessible_value_finalize, + .equal = gtk_reference_accessible_value_equal, + .print = gtk_reference_accessible_value_print, +}; + +GtkAccessibleValue * +gtk_reference_accessible_value_new (GtkAccessible *ref) +{ + g_return_val_if_fail (GTK_IS_ACCESSIBLE (ref), NULL); + + GtkAccessibleValue *res = gtk_accessible_value_alloc (>K_REFERENCE_ACCESSIBLE_VALUE); + + GtkReferenceAccessibleValue *self = (GtkReferenceAccessibleValue *) res; + + self->ref = ref; + g_object_weak_ref (G_OBJECT (self->ref), remove_weak_ref, self); + + return res; +} + +GtkAccessible * +gtk_reference_accessible_value_get (const GtkAccessibleValue *value) +{ + GtkReferenceAccessibleValue *self = (GtkReferenceAccessibleValue *) value; + + g_return_val_if_fail (value != NULL, 0); + g_return_val_if_fail (value->value_class == >K_REFERENCE_ACCESSIBLE_VALUE, 0); + + return self->ref; +} + /* }}} */ /* {{{ Collection API */ @@ -379,7 +466,8 @@ typedef enum { GTK_ACCESSIBLE_COLLECT_TRISTATE, GTK_ACCESSIBLE_COLLECT_ENUM, GTK_ACCESSIBLE_COLLECT_NUMBER, - GTK_ACCESSIBLE_COLLECT_STRING + GTK_ACCESSIBLE_COLLECT_STRING, + GTK_ACCESSIBLE_COLLECT_REF } GtkAccessibleCollectType; typedef struct { @@ -412,7 +500,7 @@ static const GtkAccessibleCollect collect_props[] = { { GTK_ACCESSIBLE_PROPERTY_FLOW_TO, GTK_ACCESSIBLE_COLLECT_STRING, "flowto", (GCallback) gtk_string_accessible_value_new }, { GTK_ACCESSIBLE_PROPERTY_HAS_POPUP, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "haspopup", (GCallback) gtk_boolean_accessible_value_new }, { GTK_ACCESSIBLE_PROPERTY_LABEL, GTK_ACCESSIBLE_COLLECT_STRING, "label", (GCallback) gtk_string_accessible_value_new }, - { GTK_ACCESSIBLE_PROPERTY_LABELLED_BY, GTK_ACCESSIBLE_COLLECT_STRING, "labelledby", (GCallback) gtk_string_accessible_value_new }, + { GTK_ACCESSIBLE_PROPERTY_LABELLED_BY, GTK_ACCESSIBLE_COLLECT_REF , "labelledby", (GCallback) gtk_reference_accessible_value_new }, { GTK_ACCESSIBLE_PROPERTY_LEVEL, GTK_ACCESSIBLE_COLLECT_INT, "level", (GCallback) gtk_int_accessible_value_new }, { GTK_ACCESSIBLE_PROPERTY_MULTI_LINE, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "multiline", (GCallback) gtk_boolean_accessible_value_new }, { GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "multiselectable", (GCallback) gtk_boolean_accessible_value_new }, @@ -436,6 +524,7 @@ typedef GtkAccessibleValue * (* GtkAccessibleValueTristateCtor) (int value); typedef GtkAccessibleValue * (* GtkAccessibleValueEnumCtor) (int value); typedef GtkAccessibleValue * (* GtkAccessibleValueNumberCtor) (double value); typedef GtkAccessibleValue * (* GtkAccessibleValueStringCtor) (const char *value); +typedef GtkAccessibleValue * (* GtkAccessibleValueRefCtor) (gpointer value); /*< private > * gtk_accessible_value_get_default_for_state: @@ -574,6 +663,17 @@ gtk_accessible_value_collect_for_state (GtkAccessibleState state, } break; + case GTK_ACCESSIBLE_COLLECT_REF: + { + GtkAccessibleValueStringCtor ctor = + (GtkAccessibleValueStringCtor) cstate->ctor; + + gpointer value = va_arg (*args, gpointer); + + res = (* ctor) (value); + } + break; + case GTK_ACCESSIBLE_COLLECT_INVALID: default: g_critical ("Unknown type for accessible state “%s”", cstate->name); @@ -671,6 +771,17 @@ gtk_accessible_value_collect_for_state_value (GtkAccessibleState state, } break; + case GTK_ACCESSIBLE_COLLECT_REF: + { + GtkAccessibleValueStringCtor ctor = + (GtkAccessibleValueStringCtor) cstate->ctor; + + gpointer value_ = g_value_get_object (value); + + res = (* ctor) (value_); + } + break; + case GTK_ACCESSIBLE_COLLECT_INVALID: default: g_critical ("Unknown value type for accessible state “%s”", cstate->name); @@ -696,6 +807,7 @@ gtk_accessible_value_get_default_for_property (GtkAccessibleProperty property) switch (cstate->value) { + /* Reference properties */ case GTK_ACCESSIBLE_PROPERTY_ACTIVE_DESCENDANT: case GTK_ACCESSIBLE_PROPERTY_CONTROLS: case GTK_ACCESSIBLE_PROPERTY_DESCRIBED_BY: @@ -703,9 +815,9 @@ gtk_accessible_value_get_default_for_property (GtkAccessibleProperty property) case GTK_ACCESSIBLE_PROPERTY_LABELLED_BY: case GTK_ACCESSIBLE_PROPERTY_OWNS: case GTK_ACCESSIBLE_PROPERTY_RELEVANT: - g_critical ("Unsupported property “%s”", cstate->name); return NULL; + /* Boolean properties */ case GTK_ACCESSIBLE_PROPERTY_HAS_POPUP: case GTK_ACCESSIBLE_PROPERTY_MULTI_LINE: case GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE: @@ -713,11 +825,24 @@ gtk_accessible_value_get_default_for_property (GtkAccessibleProperty property) case GTK_ACCESSIBLE_PROPERTY_REQUIRED: return gtk_boolean_accessible_value_new (FALSE); + /* Integer properties */ case GTK_ACCESSIBLE_PROPERTY_LEVEL: case GTK_ACCESSIBLE_PROPERTY_POS_IN_SET: case GTK_ACCESSIBLE_PROPERTY_SET_SIZE: return gtk_int_accessible_value_new (0); + /* Number properties */ + case GTK_ACCESSIBLE_PROPERTY_VALUE_MAX: + case GTK_ACCESSIBLE_PROPERTY_VALUE_MIN: + case GTK_ACCESSIBLE_PROPERTY_VALUE_NOW: + return gtk_number_accessible_value_new (0); + + /* String properties */ + case GTK_ACCESSIBLE_PROPERTY_LABEL: + case GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT: + return gtk_string_accessible_value_new (""); + + /* Token properties */ case GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE: return gtk_autocomplete_accessible_value_new (GTK_ACCESSIBLE_AUTOCOMPLETE_NONE); @@ -727,15 +852,6 @@ gtk_accessible_value_get_default_for_property (GtkAccessibleProperty property) case GTK_ACCESSIBLE_PROPERTY_SORT: return gtk_sort_accessible_value_new (GTK_ACCESSIBLE_SORT_NONE); - case GTK_ACCESSIBLE_PROPERTY_VALUE_MAX: - case GTK_ACCESSIBLE_PROPERTY_VALUE_MIN: - case GTK_ACCESSIBLE_PROPERTY_VALUE_NOW: - return gtk_number_accessible_value_new (0); - - case GTK_ACCESSIBLE_PROPERTY_LABEL: - case GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT: - return gtk_string_accessible_value_new (""); - default: g_critical ("Unknown value for accessible state “%s”", cstate->name); break; @@ -830,6 +946,17 @@ gtk_accessible_value_collect_for_property (GtkAccessibleProperty property, } break; + case GTK_ACCESSIBLE_COLLECT_REF: + { + GtkAccessibleValueStringCtor ctor = + (GtkAccessibleValueStringCtor) cstate->ctor; + + gpointer value = va_arg (*args, gpointer); + + res = (* ctor) (value); + } + break; + case GTK_ACCESSIBLE_COLLECT_INVALID: default: g_critical ("Unknown type for accessible state “%s”", cstate->name); @@ -925,6 +1052,17 @@ gtk_accessible_value_collect_for_property_value (GtkAccessibleProperty property } break; + case GTK_ACCESSIBLE_COLLECT_REF: + { + GtkAccessibleValueStringCtor ctor = + (GtkAccessibleValueStringCtor) cstate->ctor; + + gpointer value_ = g_value_get_object (value); + + res = (* ctor) (value_); + } + break; + case GTK_ACCESSIBLE_COLLECT_INVALID: default: g_critical ("Unknown value type for accessible state “%s”", cstate->name); diff --git a/gtk/gtkaccessiblevalueprivate.h b/gtk/gtkaccessiblevalueprivate.h index d924fa0f9f..3c007aedbe 100644 --- a/gtk/gtkaccessiblevalueprivate.h +++ b/gtk/gtkaccessiblevalueprivate.h @@ -22,6 +22,7 @@ #include +#include "gtkaccessible.h" #include "gtkenums.h" G_BEGIN_DECLS @@ -135,6 +136,9 @@ double gtk_number_accessible_value_get (const G GtkAccessibleValue * gtk_string_accessible_value_new (const char *value); const char * gtk_string_accessible_value_get (const GtkAccessibleValue *value); +GtkAccessibleValue * gtk_reference_accessible_value_new (GtkAccessible *value); +GtkAccessible * gtk_reference_accessible_value_get (const GtkAccessibleValue *value); + /* Tri-state values */ GtkAccessibleValue * gtk_expanded_accessible_value_new (int value); int gtk_expanded_accessible_value_get (const GtkAccessibleValue *value); diff --git a/gtk/gtkatcontext.c b/gtk/gtkatcontext.c index 5627160b40..4fe0b8176f 100644 --- a/gtk/gtkatcontext.c +++ b/gtk/gtkatcontext.c @@ -57,6 +57,7 @@ gtk_at_context_finalize (GObject *gobject) GtkATContext *self = GTK_AT_CONTEXT (gobject); gtk_accessible_state_set_unref (self->states); + gtk_accessible_property_set_unref (self->properties); G_OBJECT_CLASS (gtk_at_context_parent_class)->finalize (gobject); } @@ -108,9 +109,11 @@ gtk_at_context_get_property (GObject *gobject, } static void -gtk_at_context_real_state_change (GtkATContext *self, - GtkAccessibleStateChange change, - GtkAccessibleStateSet *states) +gtk_at_context_real_state_change (GtkATContext *self, + GtkAccessibleStateChange changed_states, + GtkAccessiblePropertyChange changed_properies, + GtkAccessibleStateSet *states, + GtkAccessiblePropertySet *properties) { } @@ -166,6 +169,7 @@ gtk_at_context_init (GtkATContext *self) self->accessible_role = GTK_ACCESSIBLE_ROLE_WIDGET; self->states = gtk_accessible_state_set_new (); + self->properties = gtk_accessible_property_set_new (); } /** @@ -252,34 +256,87 @@ gtk_at_context_create (GtkAccessibleRole accessible_role, } /*< private > - * gtk_at_context_update_state: + * gtk_at_context_update: * @self: a #GtkATContext * * Notifies the AT connected to this #GtkATContext that the accessible - * state has changed. + * state and its properties have changed. */ void -gtk_at_context_update_state (GtkATContext *self) +gtk_at_context_update (GtkATContext *self) { g_return_if_fail (GTK_IS_AT_CONTEXT (self)); - GtkAccessibleStateChange change = 0; + GtkAccessibleStateChange changed_states = 0; + GtkAccessiblePropertyChange changed_properties = 0; for (int i = 0; i < GTK_ACCESSIBLE_STATE_SELECTED; i++) { if (gtk_accessible_state_set_contains (self->states, i)) - change |= (1 << i); + changed_states |= (1 << i); } - GTK_AT_CONTEXT_GET_CLASS (self)->state_change (self, change, self->states); + for (int i = 0; i < GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT; i++) + { + if (gtk_accessible_property_set_contains (self->properties, i)) + changed_properties |= (1 << i); + } + + GTK_AT_CONTEXT_GET_CLASS (self)->state_change (self, + changed_states, + changed_properties, + self->states, + self->properties); } +/*< private > + * gtk_at_context_set_state: + * @self: a #GtkATContext + * @state: a #GtkAccessibleState + * @value: (nullable): #GtkAccessibleValue + * + * Sets the @value for the given @state of a #GtkATContext. + * + * If @value is %NULL, the state is unset. + * + * This function will accumulate state changes until gtk_at_context_update_state() + * is called. + */ void -gtk_at_context_set_state (GtkATContext *self, - GtkAccessibleState state, - GtkAccessibleValue *value) +gtk_at_context_set_accessible_state (GtkATContext *self, + GtkAccessibleState state, + GtkAccessibleValue *value) { g_return_if_fail (GTK_IS_AT_CONTEXT (self)); - gtk_accessible_state_set_add (self->states, state, value); + if (value != NULL) + gtk_accessible_state_set_add (self->states, state, value); + else + gtk_accessible_state_set_remove (self->states, state); +} + +/*< private > + * gtk_at_context_set_accessible_property: + * @self: a #GtkATContext + * @property: a #GtkAccessibleProperty + * @value: (nullable): #GtkAccessibleValue + * + * Sets the @value for the given @property of a #GtkATContext. + * + * If @value is %NULL, the property is unset. + * + * This function will accumulate property changes until gtk_at_context_update_state() + * is called. + */ +void +gtk_at_context_set_accessible_property (GtkATContext *self, + GtkAccessibleProperty property, + GtkAccessibleValue *value) +{ + g_return_if_fail (GTK_IS_AT_CONTEXT (self)); + + if (value != NULL) + gtk_accessible_property_set_add (self->properties, property, value); + else + gtk_accessible_property_set_remove (self->properties, property); } diff --git a/gtk/gtkatcontextprivate.h b/gtk/gtkatcontextprivate.h index 8ee334ca86..4df4d26bb5 100644 --- a/gtk/gtkatcontextprivate.h +++ b/gtk/gtkatcontextprivate.h @@ -23,21 +23,48 @@ #include "gtkatcontext.h" #include "gtkaccessiblestatesetprivate.h" +#include "gtkaccessiblepropertysetprivate.h" G_BEGIN_DECLS typedef enum { - GTK_ACCESSIBLE_STATE_CHANGE_BUSY = 1 << GTK_ACCESSIBLE_STATE_BUSY, - GTK_ACCESSIBLE_STATE_CHANGE_CHECKED = 1 << GTK_ACCESSIBLE_STATE_CHECKED, - GTK_ACCESSIBLE_STATE_CHANGE_DISABLED = 1 << GTK_ACCESSIBLE_STATE_DISABLED, - GTK_ACCESSIBLE_STATE_CHANGE_EXPANDED = 1 << GTK_ACCESSIBLE_STATE_EXPANDED, - GTK_ACCESSIBLE_STATE_CHANGE_GRABBED = 1 << GTK_ACCESSIBLE_STATE_GRABBED, - GTK_ACCESSIBLE_STATE_CHANGE_HIDDEN = 1 << GTK_ACCESSIBLE_STATE_HIDDEN, - GTK_ACCESSIBLE_STATE_CHANGE_INVALID = 1 << GTK_ACCESSIBLE_STATE_INVALID, - GTK_ACCESSIBLE_STATE_CHANGE_PRESSED = 1 << GTK_ACCESSIBLE_STATE_PRESSED, - GTK_ACCESSIBLE_STATE_CHANGE_SELECTED = 1 << GTK_ACCESSIBLE_STATE_SELECTED + GTK_ACCESSIBLE_STATE_CHANGE_BUSY = 1 << GTK_ACCESSIBLE_STATE_BUSY, + GTK_ACCESSIBLE_STATE_CHANGE_CHECKED = 1 << GTK_ACCESSIBLE_STATE_CHECKED, + GTK_ACCESSIBLE_STATE_CHANGE_DISABLED = 1 << GTK_ACCESSIBLE_STATE_DISABLED, + GTK_ACCESSIBLE_STATE_CHANGE_EXPANDED = 1 << GTK_ACCESSIBLE_STATE_EXPANDED, + GTK_ACCESSIBLE_STATE_CHANGE_GRABBED = 1 << GTK_ACCESSIBLE_STATE_GRABBED, + GTK_ACCESSIBLE_STATE_CHANGE_HIDDEN = 1 << GTK_ACCESSIBLE_STATE_HIDDEN, + GTK_ACCESSIBLE_STATE_CHANGE_INVALID = 1 << GTK_ACCESSIBLE_STATE_INVALID, + GTK_ACCESSIBLE_STATE_CHANGE_PRESSED = 1 << GTK_ACCESSIBLE_STATE_PRESSED, + GTK_ACCESSIBLE_STATE_CHANGE_SELECTED = 1 << GTK_ACCESSIBLE_STATE_SELECTED } GtkAccessibleStateChange; +typedef enum { + GTK_ACCESSIBLE_PROPERTY_CHANGE_ACTIVE_DESCENDANT = 1 << GTK_ACCESSIBLE_PROPERTY_ACTIVE_DESCENDANT, + GTK_ACCESSIBLE_PROPERTY_CHANGE_AUTOCOMPLETE = 1 << GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE, + GTK_ACCESSIBLE_PROPERTY_CHANGE_CONTROLS = 1 << GTK_ACCESSIBLE_PROPERTY_CONTROLS, + GTK_ACCESSIBLE_PROPERTY_CHANGE_DESCRIBED_BY = 1 << GTK_ACCESSIBLE_PROPERTY_DESCRIBED_BY, + GTK_ACCESSIBLE_PROPERTY_CHANGE_FLOW_TO = 1 << GTK_ACCESSIBLE_PROPERTY_FLOW_TO, + GTK_ACCESSIBLE_PROPERTY_CHANGE_HAS_POPUP = 1 << GTK_ACCESSIBLE_PROPERTY_HAS_POPUP, + GTK_ACCESSIBLE_PROPERTY_CHANGE_LABEL = 1 << GTK_ACCESSIBLE_PROPERTY_LABEL, + GTK_ACCESSIBLE_PROPERTY_CHANGE_LABELLED_BY = 1 << GTK_ACCESSIBLE_PROPERTY_LABELLED_BY, + GTK_ACCESSIBLE_PROPERTY_CHANGE_LEVEL = 1 << GTK_ACCESSIBLE_PROPERTY_LEVEL, + GTK_ACCESSIBLE_PROPERTY_CHANGE_MULTI_LINE = 1 << GTK_ACCESSIBLE_PROPERTY_MULTI_LINE, + GTK_ACCESSIBLE_PROPERTY_CHANGE_MULTI_SELECTABLE = 1 << GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE, + GTK_ACCESSIBLE_PROPERTY_CHANGE_ORIENTATION = 1 << GTK_ACCESSIBLE_PROPERTY_ORIENTATION, + GTK_ACCESSIBLE_PROPERTY_CHANGE_OWNS = 1 << GTK_ACCESSIBLE_PROPERTY_OWNS, + GTK_ACCESSIBLE_PROPERTY_CHANGE_POS_IN_SET = 1 << GTK_ACCESSIBLE_PROPERTY_POS_IN_SET, + GTK_ACCESSIBLE_PROPERTY_CHANGE_READ_ONLY = 1 << GTK_ACCESSIBLE_PROPERTY_READ_ONLY, + GTK_ACCESSIBLE_PROPERTY_CHANGE_RELEVANT = 1 << GTK_ACCESSIBLE_PROPERTY_RELEVANT, + GTK_ACCESSIBLE_PROPERTY_CHANGE_REQUIRED = 1 << GTK_ACCESSIBLE_PROPERTY_REQUIRED, + GTK_ACCESSIBLE_PROPERTY_CHANGE_SET_SIZE = 1 << GTK_ACCESSIBLE_PROPERTY_SET_SIZE, + GTK_ACCESSIBLE_PROPERTY_CHANGE_SORT = 1 << GTK_ACCESSIBLE_PROPERTY_SORT, + GTK_ACCESSIBLE_PROPERTY_CHANGE_VALUE_MAX = 1 << GTK_ACCESSIBLE_PROPERTY_VALUE_MAX, + GTK_ACCESSIBLE_PROPERTY_CHANGE_VALUE_MIN = 1 << GTK_ACCESSIBLE_PROPERTY_VALUE_MIN, + GTK_ACCESSIBLE_PROPERTY_CHANGE_VALUE_NOW = 1 << GTK_ACCESSIBLE_PROPERTY_VALUE_NOW, + GTK_ACCESSIBLE_PROPERTY_CHANGE_VALUE_TEXT = 1 << GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT +} GtkAccessiblePropertyChange; + struct _GtkATContext { GObject parent_instance; @@ -46,24 +73,30 @@ struct _GtkATContext GtkAccessible *accessible; GtkAccessibleStateSet *states; + GtkAccessiblePropertySet *properties; }; struct _GtkATContextClass { GObjectClass parent_class; - void (* state_change) (GtkATContext *self, - GtkAccessibleStateChange changed, - GtkAccessibleStateSet *states); + void (* state_change) (GtkATContext *self, + GtkAccessibleStateChange changed_states, + GtkAccessiblePropertyChange changed_properties, + GtkAccessibleStateSet *states, + GtkAccessiblePropertySet *properties); }; -GtkATContext * gtk_at_context_create (GtkAccessibleRole accessible_role, - GtkAccessible *accessible); +GtkATContext * gtk_at_context_create (GtkAccessibleRole accessible_role, + GtkAccessible *accessible); -void gtk_at_context_update_state (GtkATContext *self); +void gtk_at_context_update (GtkATContext *self); -void gtk_at_context_set_state (GtkATContext *self, - GtkAccessibleState state, - GtkAccessibleValue *value); +void gtk_at_context_set_accessible_state (GtkATContext *self, + GtkAccessibleState state, + GtkAccessibleValue *value); +void gtk_at_context_set_accessible_property (GtkATContext *self, + GtkAccessibleProperty property, + GtkAccessibleValue *value); G_END_DECLS diff --git a/gtk/gtktestatcontext.c b/gtk/gtktestatcontext.c index 8324d44375..f89e354451 100644 --- a/gtk/gtktestatcontext.c +++ b/gtk/gtktestatcontext.c @@ -33,20 +33,27 @@ struct _GtkTestATContext G_DEFINE_TYPE (GtkTestATContext, gtk_test_at_context, GTK_TYPE_AT_CONTEXT) static void -gtk_test_at_context_state_change (GtkATContext *self, - GtkAccessibleStateChange change, - GtkAccessibleStateSet *states) +gtk_test_at_context_state_change (GtkATContext *self, + GtkAccessibleStateChange changed_states, + GtkAccessiblePropertyChange changed_properties, + GtkAccessibleStateSet *states, + GtkAccessiblePropertySet *properties) { GtkAccessible *accessible = gtk_at_context_get_accessible (self); GtkAccessibleRole role = gtk_at_context_get_accessible_role (self); - char *state = gtk_accessible_state_set_to_string (states); + char *states_str = gtk_accessible_state_set_to_string (states); + char *properties_str = gtk_accessible_property_set_to_string (properties); - g_print ("Accessible state changed for accessible “%s”, with role %d: %s\n", + g_print ("*** Accessible state changed for accessible “%s”, with role %d:\n" + "*** states = %s\n" + "*** properties = %s\n", G_OBJECT_TYPE_NAME (accessible), role, - state); + states_str, + properties_str); - g_free (state); + g_free (states_str); + g_free (properties_str); } static void