/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ /* * st-widget.c: Base class for St actors * * Copyright 2007 OpenedHand * Copyright 2008, 2009 Intel Corporation. * Copyright 2009, 2010 Red Hat, Inc. * Copyright 2009 Abderrahim Kitouni * Copyright 2009, 2010 Florian Müllner * Copyright 2010 Adel Gadllah * Copyright 2012 Igalia, S.L. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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 program. If not, see . */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #include "st-widget.h" #include "st-label.h" #include "st-private.h" #include "st-settings.h" #include "st-texture-cache.h" #include "st-theme-context.h" #include "st-theme-node-transition.h" #include "st-theme-node-private.h" #include "st-drawing-area.h" #include "st-widget-accessible.h" #include /* This is set in stone and also hard-coded in GDK. */ #define VIRTUAL_CORE_POINTER_ID 2 /* * Forward declaration for sake of StWidgetChild */ typedef struct _StWidgetPrivate StWidgetPrivate; struct _StWidgetPrivate { StThemeNode *theme_node; gchar *pseudo_class; gchar *style_class; gchar *inline_style; StThemeNodeTransition *transition_animation; guint is_style_dirty : 1; guint first_child_dirty : 1; guint last_child_dirty : 1; guint draw_bg_color : 1; guint draw_border_internal : 1; guint track_hover : 1; guint hover : 1; guint can_focus : 1; gulong texture_file_changed_id; guint update_child_styles_id; AtkObject *accessible; AtkRole accessible_role; AtkStateSet *local_state_set; ClutterActor *label_actor; gchar *accessible_name; StWidget *last_visible_child; StWidget *first_visible_child; StThemeNodePaintState paint_states[2]; int current_paint_state : 2; }; /** * SECTION:st-widget * @short_description: Base class for stylable actors * * #StWidget is a simple abstract class on top of #ClutterActor. It * provides basic themeing properties. * * Actors in the St library should subclass #StWidget if they plan * to obey to a certain #StStyle. */ enum { PROP_0, PROP_PSEUDO_CLASS, PROP_STYLE_CLASS, PROP_STYLE, PROP_TRACK_HOVER, PROP_HOVER, PROP_CAN_FOCUS, PROP_LABEL_ACTOR, PROP_ACCESSIBLE_ROLE, PROP_ACCESSIBLE_NAME, N_PROPS }; static GParamSpec *props[N_PROPS] = { NULL, }; enum { STYLE_CHANGED, POPUP_MENU, LAST_SIGNAL }; static guint signals[LAST_SIGNAL] = { 0, }; G_DEFINE_TYPE_WITH_PRIVATE (StWidget, st_widget, CLUTTER_TYPE_ACTOR); #define ST_WIDGET_PRIVATE(w) ((StWidgetPrivate *)st_widget_get_instance_private (w)) static void st_widget_recompute_style (StWidget *widget, StThemeNode *old_theme_node); static gboolean st_widget_real_navigate_focus (StWidget *widget, ClutterActor *from, StDirectionType direction); static AtkObject * st_widget_get_accessible (ClutterActor *actor); static gboolean st_widget_has_accessible (ClutterActor *actor); static void st_widget_set_property (GObject *gobject, guint prop_id, const GValue *value, GParamSpec *pspec) { StWidget *actor = ST_WIDGET (gobject); switch (prop_id) { case PROP_PSEUDO_CLASS: st_widget_set_style_pseudo_class (actor, g_value_get_string (value)); break; case PROP_STYLE_CLASS: st_widget_set_style_class_name (actor, g_value_get_string (value)); break; case PROP_STYLE: st_widget_set_style (actor, g_value_get_string (value)); break; case PROP_TRACK_HOVER: st_widget_set_track_hover (actor, g_value_get_boolean (value)); break; case PROP_HOVER: st_widget_set_hover (actor, g_value_get_boolean (value)); break; case PROP_CAN_FOCUS: st_widget_set_can_focus (actor, g_value_get_boolean (value)); break; case PROP_LABEL_ACTOR: st_widget_set_label_actor (actor, g_value_get_object (value)); break; case PROP_ACCESSIBLE_ROLE: st_widget_set_accessible_role (actor, g_value_get_enum (value)); break; case PROP_ACCESSIBLE_NAME: st_widget_set_accessible_name (actor, g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } } static void st_widget_get_property (GObject *gobject, guint prop_id, GValue *value, GParamSpec *pspec) { StWidget *actor = ST_WIDGET (gobject); StWidgetPrivate *priv = st_widget_get_instance_private (ST_WIDGET (gobject)); switch (prop_id) { case PROP_PSEUDO_CLASS: g_value_set_string (value, priv->pseudo_class); break; case PROP_STYLE_CLASS: g_value_set_string (value, priv->style_class); break; case PROP_STYLE: g_value_set_string (value, priv->inline_style); break; case PROP_TRACK_HOVER: g_value_set_boolean (value, priv->track_hover); break; case PROP_HOVER: g_value_set_boolean (value, priv->hover); break; case PROP_CAN_FOCUS: g_value_set_boolean (value, priv->can_focus); break; case PROP_LABEL_ACTOR: g_value_set_object (value, priv->label_actor); break; case PROP_ACCESSIBLE_ROLE: g_value_set_enum (value, st_widget_get_accessible_role (actor)); break; case PROP_ACCESSIBLE_NAME: g_value_set_string (value, priv->accessible_name); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } } static void st_widget_remove_transition (StWidget *widget) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); if (priv->transition_animation) { g_object_run_dispose (G_OBJECT (priv->transition_animation)); g_object_unref (priv->transition_animation); priv->transition_animation = NULL; } } static void next_paint_state (StWidget *widget) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); priv->current_paint_state = (priv->current_paint_state + 1) % G_N_ELEMENTS (priv->paint_states); } static StThemeNodePaintState * current_paint_state (StWidget *widget) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); return &priv->paint_states[priv->current_paint_state]; } static void st_widget_texture_cache_changed (StTextureCache *cache, GFile *file, gpointer user_data) { StWidget *actor = ST_WIDGET (user_data); StWidgetPrivate *priv = st_widget_get_instance_private (actor); gboolean changed = FALSE; int i; for (i = 0; i < G_N_ELEMENTS (priv->paint_states); i++) { StThemeNodePaintState *paint_state = &priv->paint_states[i]; changed |= st_theme_node_paint_state_invalidate_for_file (paint_state, file); } if (changed && clutter_actor_is_mapped (CLUTTER_ACTOR (actor))) clutter_actor_queue_redraw (CLUTTER_ACTOR (actor)); } static void st_widget_dispose (GObject *gobject) { StWidget *actor = ST_WIDGET (gobject); StWidgetPrivate *priv = st_widget_get_instance_private (actor); g_clear_pointer (&priv->theme_node, g_object_unref); st_widget_remove_transition (actor); g_clear_pointer (&priv->label_actor, g_object_unref); g_clear_signal_handler (&priv->texture_file_changed_id, st_texture_cache_get_default ()); g_clear_object (&priv->first_visible_child); g_clear_object (&priv->last_visible_child); G_OBJECT_CLASS (st_widget_parent_class)->dispose (gobject); g_clear_handle_id (&priv->update_child_styles_id, g_source_remove); } static void st_widget_finalize (GObject *gobject) { StWidgetPrivate *priv = st_widget_get_instance_private (ST_WIDGET (gobject)); guint i; g_free (priv->style_class); g_free (priv->pseudo_class); g_object_unref (priv->local_state_set); g_free (priv->accessible_name); g_free (priv->inline_style); for (i = 0; i < G_N_ELEMENTS (priv->paint_states); i++) st_theme_node_paint_state_free (&priv->paint_states[i]); G_OBJECT_CLASS (st_widget_parent_class)->finalize (gobject); } static void st_widget_get_preferred_width (ClutterActor *self, gfloat for_height, gfloat *min_width_p, gfloat *natural_width_p) { StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self)); st_theme_node_adjust_for_width (theme_node, &for_height); CLUTTER_ACTOR_CLASS (st_widget_parent_class)->get_preferred_width (self, for_height, min_width_p, natural_width_p); st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p); } static void st_widget_get_preferred_height (ClutterActor *self, gfloat for_width, gfloat *min_height_p, gfloat *natural_height_p) { StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self)); st_theme_node_adjust_for_width (theme_node, &for_width); CLUTTER_ACTOR_CLASS (st_widget_parent_class)->get_preferred_height (self, for_width, min_height_p, natural_height_p); st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p); } static void st_widget_allocate (ClutterActor *actor, const ClutterActorBox *box) { StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor)); ClutterActorBox content_box; /* Note that we can't just chain up to clutter_actor_real_allocate -- * Clutter does some dirty tricks for backwards compatibility. * Clutter also passes the actor's allocation directly to the layout * manager, meaning that we can't modify it for children only. */ clutter_actor_set_allocation (actor, box); st_theme_node_get_content_box (theme_node, box, &content_box); /* If we've chained up to here, we want to allocate the children using the * currently installed layout manager */ clutter_layout_manager_allocate (clutter_actor_get_layout_manager (actor), CLUTTER_CONTAINER (actor), &content_box); } /** * st_widget_paint_background: * @widget: The #StWidget * * Paint the background of the widget. This is meant to be called by * subclasses of StWidget that need to paint the background without * painting children. */ void st_widget_paint_background (StWidget *widget, ClutterPaintContext *paint_context) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); CoglFramebuffer *framebuffer; StThemeNode *theme_node; ClutterActorBox allocation; float resource_scale; guint8 opacity; resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (widget)); framebuffer = clutter_paint_context_get_framebuffer (paint_context); theme_node = st_widget_get_theme_node (widget); clutter_actor_get_allocation_box (CLUTTER_ACTOR (widget), &allocation); opacity = clutter_actor_get_paint_opacity (CLUTTER_ACTOR (widget)); if (priv->transition_animation) st_theme_node_transition_paint (priv->transition_animation, framebuffer, &allocation, opacity, resource_scale); else st_theme_node_paint (theme_node, current_paint_state (widget), framebuffer, &allocation, opacity, resource_scale); } static void st_widget_paint (ClutterActor *actor, ClutterPaintContext *paint_context) { st_widget_paint_background (ST_WIDGET (actor), paint_context); /* Chain up so we paint children. */ CLUTTER_ACTOR_CLASS (st_widget_parent_class)->paint (actor, paint_context); } static void st_widget_parent_set (ClutterActor *widget, ClutterActor *old_parent) { StWidget *self = ST_WIDGET (widget); ClutterActorClass *parent_class; parent_class = CLUTTER_ACTOR_CLASS (st_widget_parent_class); if (parent_class->parent_set) parent_class->parent_set (widget, old_parent); st_widget_style_changed (self); } static void st_widget_map (ClutterActor *actor) { StWidget *self = ST_WIDGET (actor); CLUTTER_ACTOR_CLASS (st_widget_parent_class)->map (actor); st_widget_ensure_style (self); } static void st_widget_unmap (ClutterActor *actor) { StWidget *self = ST_WIDGET (actor); StWidgetPrivate *priv = st_widget_get_instance_private (self); CLUTTER_ACTOR_CLASS (st_widget_parent_class)->unmap (actor); if (priv->track_hover && priv->hover) st_widget_set_hover (self, FALSE); } static void notify_children_of_style_change (ClutterActor *self) { ClutterActorIter iter; ClutterActor *actor; clutter_actor_iter_init (&iter, self); while (clutter_actor_iter_next (&iter, &actor)) { if (ST_IS_WIDGET (actor)) st_widget_style_changed (ST_WIDGET (actor)); else notify_children_of_style_change (actor); } } static void st_widget_real_style_changed (StWidget *self) { clutter_actor_queue_redraw ((ClutterActor *) self); } void st_widget_style_changed (StWidget *widget) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); StThemeNode *old_theme_node = NULL; priv->is_style_dirty = TRUE; if (priv->theme_node) { old_theme_node = priv->theme_node; priv->theme_node = NULL; } /* update the style only if we are mapped */ if (clutter_actor_is_mapped (CLUTTER_ACTOR (widget))) st_widget_recompute_style (widget, old_theme_node); /* Descend through all children. If the actor is not mapped, * children will clear their theme node without recomputing style. */ notify_children_of_style_change (CLUTTER_ACTOR (widget)); if (old_theme_node) g_object_unref (old_theme_node); } static void on_theme_context_changed (StThemeContext *context, ClutterStage *stage) { notify_children_of_style_change (CLUTTER_ACTOR (stage)); } static StThemeNode * get_root_theme_node (ClutterStage *stage) { StThemeContext *context = st_theme_context_get_for_stage (stage); if (!g_object_get_data (G_OBJECT (context), "st-theme-initialized")) { g_object_set_data (G_OBJECT (context), "st-theme-initialized", GUINT_TO_POINTER (1)); g_signal_connect (G_OBJECT (context), "changed", G_CALLBACK (on_theme_context_changed), stage); } return st_theme_context_get_root_node (context); } /** * st_widget_get_theme_node: * @widget: a #StWidget * * Gets the theme node holding style information for the widget. * The theme node is used to access standard and custom CSS * properties of the widget. * * Note: it is a fatal error to call this on a widget that is * not been added to a stage. * * Returns: (transfer none): the theme node for the widget. * This is owned by the widget. When attributes of the widget * or the environment that affect the styling change (for example * the style_class property of the widget), it will be recreated, * and the ::style-changed signal will be emitted on the widget. */ StThemeNode * st_widget_get_theme_node (StWidget *widget) { StWidgetPrivate *priv; g_return_val_if_fail (ST_IS_WIDGET (widget), NULL); priv = st_widget_get_instance_private (widget); if (priv->theme_node == NULL) { StThemeContext *context; StThemeNode *tmp_node; StThemeNode *parent_node = NULL; ClutterStage *stage = NULL; ClutterActor *parent; char *pseudo_class, *direction_pseudo_class; parent = clutter_actor_get_parent (CLUTTER_ACTOR (widget)); while (parent != NULL) { if (parent_node == NULL && ST_IS_WIDGET (parent)) parent_node = st_widget_get_theme_node (ST_WIDGET (parent)); else if (CLUTTER_IS_STAGE (parent)) stage = CLUTTER_STAGE (parent); parent = clutter_actor_get_parent (parent); } if (stage == NULL) { g_autofree char *desc = st_describe_actor (CLUTTER_ACTOR (widget)); g_critical ("st_widget_get_theme_node called on the widget %s which is not in the stage.", desc); return g_object_new (ST_TYPE_THEME_NODE, NULL); } if (parent_node == NULL) parent_node = get_root_theme_node (CLUTTER_STAGE (stage)); /* Always append a "magic" pseudo class indicating the text * direction, to allow to adapt the CSS when necessary without * requiring separate style sheets. */ if (clutter_actor_get_text_direction (CLUTTER_ACTOR (widget)) == CLUTTER_TEXT_DIRECTION_RTL) direction_pseudo_class = (char *)"rtl"; else direction_pseudo_class = (char *)"ltr"; if (priv->pseudo_class) pseudo_class = g_strconcat(priv->pseudo_class, " ", direction_pseudo_class, NULL); else pseudo_class = direction_pseudo_class; context = st_theme_context_get_for_stage (stage); tmp_node = st_theme_node_new (context, parent_node, NULL, G_OBJECT_TYPE (widget), clutter_actor_get_name (CLUTTER_ACTOR (widget)), priv->style_class, pseudo_class, priv->inline_style); if (pseudo_class != direction_pseudo_class) g_free (pseudo_class); priv->theme_node = g_object_ref (st_theme_context_intern_node (context, tmp_node)); g_object_unref (tmp_node); } return priv->theme_node; } /** * st_widget_peek_theme_node: * @widget: a #StWidget * * Returns the theme node for the widget if it has already been * computed, %NULL if the widget hasn't been added to a stage or the theme * node hasn't been computed. If %NULL is returned, then ::style-changed * will be reliably emitted before the widget is allocated or painted. * * Returns: (transfer none): the theme node for the widget. * This is owned by the widget. When attributes of the widget * or the environment that affect the styling change (for example * the style_class property of the widget), it will be recreated, * and the ::style-changed signal will be emitted on the widget. */ StThemeNode * st_widget_peek_theme_node (StWidget *widget) { g_return_val_if_fail (ST_IS_WIDGET (widget), NULL); return ST_WIDGET_PRIVATE (widget)->theme_node; } static gboolean st_widget_enter (ClutterActor *actor, ClutterCrossingEvent *event) { StWidgetPrivate *priv = st_widget_get_instance_private (ST_WIDGET (actor)); if (priv->track_hover) { if (clutter_actor_contains (actor, event->source)) st_widget_set_hover (ST_WIDGET (actor), TRUE); else { /* The widget has a grab and is being told about an * enter-event outside its hierarchy. Hopefully we already * got a leave-event, but if not, handle it now. */ st_widget_set_hover (ST_WIDGET (actor), FALSE); } } if (CLUTTER_ACTOR_CLASS (st_widget_parent_class)->enter_event) return CLUTTER_ACTOR_CLASS (st_widget_parent_class)->enter_event (actor, event); else return FALSE; } static gboolean st_widget_leave (ClutterActor *actor, ClutterCrossingEvent *event) { StWidgetPrivate *priv = st_widget_get_instance_private (ST_WIDGET (actor)); if (priv->track_hover) { if (!event->related || !clutter_actor_contains (actor, event->related)) st_widget_set_hover (ST_WIDGET (actor), FALSE); } if (CLUTTER_ACTOR_CLASS (st_widget_parent_class)->leave_event) return CLUTTER_ACTOR_CLASS (st_widget_parent_class)->leave_event (actor, event); else return FALSE; } static void st_widget_key_focus_in (ClutterActor *actor) { StWidget *widget = ST_WIDGET (actor); st_widget_add_style_pseudo_class (widget, "focus"); } static void st_widget_key_focus_out (ClutterActor *actor) { StWidget *widget = ST_WIDGET (actor); st_widget_remove_style_pseudo_class (widget, "focus"); } static gboolean st_widget_key_press_event (ClutterActor *actor, ClutterKeyEvent *event) { if (event->keyval == CLUTTER_KEY_Menu || (event->keyval == CLUTTER_KEY_F10 && (event->modifier_state & CLUTTER_SHIFT_MASK))) { st_widget_popup_menu (ST_WIDGET (actor)); return TRUE; } return FALSE; } static gboolean st_widget_get_paint_volume (ClutterActor *self, ClutterPaintVolume *volume) { ClutterActorBox paint_box, alloc_box; StThemeNode *theme_node; StWidgetPrivate *priv; graphene_point3d_t origin; /* Setting the paint volume does not make sense when we don't have any allocation */ if (!clutter_actor_has_allocation (self)) return FALSE; priv = st_widget_get_instance_private (ST_WIDGET (self)); theme_node = st_widget_get_theme_node (ST_WIDGET (self)); clutter_actor_get_allocation_box (self, &alloc_box); if (priv->transition_animation) st_theme_node_transition_get_paint_box (priv->transition_animation, &alloc_box, &paint_box); else st_theme_node_get_paint_box (theme_node, &alloc_box, &paint_box); origin.x = paint_box.x1 - alloc_box.x1; origin.y = paint_box.y1 - alloc_box.y1; origin.z = 0.0f; clutter_paint_volume_set_origin (volume, &origin); clutter_paint_volume_set_width (volume, paint_box.x2 - paint_box.x1); clutter_paint_volume_set_height (volume, paint_box.y2 - paint_box.y1); if (!clutter_actor_get_clip_to_allocation (self)) { ClutterActor *child; /* Based on ClutterGroup/ClutterBox; include the children's * paint volumes, since they may paint outside our allocation. */ for (child = clutter_actor_get_first_child (self); child != NULL; child = clutter_actor_get_next_sibling (child)) { const ClutterPaintVolume *child_volume; if (!clutter_actor_is_visible (child)) continue; child_volume = clutter_actor_get_transformed_paint_volume (child, self); if (!child_volume) return FALSE; clutter_paint_volume_union (volume, child_volume); } } return TRUE; } static GList * st_widget_real_get_focus_chain (StWidget *widget) { GList *children, *l, *visible = NULL; children = clutter_actor_get_children (CLUTTER_ACTOR (widget)); for (l = children; l; l = l->next) { if (clutter_actor_is_visible (CLUTTER_ACTOR (l->data))) visible = g_list_prepend (visible, l->data); } g_list_free (children); return g_list_reverse (visible); } static void st_widget_resource_scale_changed (ClutterActor *actor) { StWidget *widget = ST_WIDGET (actor); StWidgetPrivate *priv = st_widget_get_instance_private (widget); int i; for (i = 0; i < G_N_ELEMENTS (priv->paint_states); i++) st_theme_node_paint_state_invalidate (&priv->paint_states[i]); if (CLUTTER_ACTOR_CLASS (st_widget_parent_class)->resource_scale_changed) CLUTTER_ACTOR_CLASS (st_widget_parent_class)->resource_scale_changed (actor); } static void st_widget_class_init (StWidgetClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass); gobject_class->set_property = st_widget_set_property; gobject_class->get_property = st_widget_get_property; gobject_class->dispose = st_widget_dispose; gobject_class->finalize = st_widget_finalize; actor_class->get_preferred_width = st_widget_get_preferred_width; actor_class->get_preferred_height = st_widget_get_preferred_height; actor_class->allocate = st_widget_allocate; actor_class->paint = st_widget_paint; actor_class->get_paint_volume = st_widget_get_paint_volume; actor_class->parent_set = st_widget_parent_set; actor_class->map = st_widget_map; actor_class->unmap = st_widget_unmap; actor_class->enter_event = st_widget_enter; actor_class->leave_event = st_widget_leave; actor_class->key_focus_in = st_widget_key_focus_in; actor_class->key_focus_out = st_widget_key_focus_out; actor_class->key_press_event = st_widget_key_press_event; actor_class->get_accessible = st_widget_get_accessible; actor_class->has_accessible = st_widget_has_accessible; actor_class->resource_scale_changed = st_widget_resource_scale_changed; klass->style_changed = st_widget_real_style_changed; klass->navigate_focus = st_widget_real_navigate_focus; klass->get_accessible_type = st_widget_accessible_get_type; klass->get_focus_chain = st_widget_real_get_focus_chain; /** * StWidget:pseudo-class: * * The pseudo-class of the actor. Typical values include "hover", "active", * "focus". */ props[PROP_PSEUDO_CLASS] = g_param_spec_string ("pseudo-class", "Pseudo Class", "Pseudo class for styling", "", ST_PARAM_READWRITE); /** * StWidget:style-class: * * The style-class of the actor for use in styling. */ props[PROP_STYLE_CLASS] = g_param_spec_string ("style-class", "Style Class", "Style class for styling", "", ST_PARAM_READWRITE); /** * StWidget:style: * * Inline style information for the actor as a ';'-separated list of * CSS properties. */ props[PROP_STYLE] = g_param_spec_string ("style", "Style", "Inline style string", "", ST_PARAM_READWRITE); /** * StWidget:track-hover: * * Determines whether the widget tracks pointer hover state. If * %TRUE (and the widget is visible and reactive), the * #StWidget:hover property and "hover" style pseudo class will be * adjusted automatically as the pointer moves in and out of the * widget. */ props[PROP_TRACK_HOVER] = g_param_spec_boolean ("track-hover", "Track hover", "Determines whether the widget tracks hover state", FALSE, ST_PARAM_READWRITE); /** * StWidget:hover: * * Whether or not the pointer is currently hovering over the widget. This is * only tracked automatically if #StWidget:track-hover is %TRUE, but you can * adjust it manually in any case. */ props[PROP_HOVER] = g_param_spec_boolean ("hover", "Hover", "Whether the pointer is hovering over the widget", FALSE, ST_PARAM_READWRITE); /** * StWidget:can-focus: * * Whether or not the widget can be focused via keyboard navigation. */ props[PROP_CAN_FOCUS] = g_param_spec_boolean ("can-focus", "Can focus", "Whether the widget can be focused via keyboard navigation", FALSE, ST_PARAM_READWRITE); /** * StWidget:label-actor: * * An actor that labels this widget. */ props[PROP_LABEL_ACTOR] = g_param_spec_object ("label-actor", "Label", "Label that identifies this widget", CLUTTER_TYPE_ACTOR, ST_PARAM_READWRITE); /** * StWidget:accessible-role: * * The accessible role of this object */ props[PROP_ACCESSIBLE_ROLE] = g_param_spec_enum ("accessible-role", "Accessible Role", "The accessible role of this object", ATK_TYPE_ROLE, ATK_ROLE_INVALID, ST_PARAM_READWRITE); /** * StWidget:accessible-name: * * Object instance's name for assistive technology access. */ props[PROP_ACCESSIBLE_NAME] = g_param_spec_string ("accessible-name", "Accessible name", "Object instance's name for assistive technology access.", NULL, ST_PARAM_READWRITE); g_object_class_install_properties (gobject_class, N_PROPS, props); /** * StWidget::style-changed: * @widget: the #StWidget * * Emitted when the style information that the widget derives from the * theme changes */ signals[STYLE_CHANGED] = g_signal_new ("style-changed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (StWidgetClass, style_changed), NULL, NULL, NULL, G_TYPE_NONE, 0); /** * StWidget::popup-menu: * @widget: the #StWidget * * Emitted when the user has requested a context menu (eg, via a keybinding) */ signals[POPUP_MENU] = g_signal_new ("popup-menu", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (StWidgetClass, popup_menu), NULL, NULL, NULL, G_TYPE_NONE, 0); } static const gchar * find_class_name (const gchar *class_list, const gchar *class_name) { gint len = strlen (class_name); const gchar *match; if (!class_list) return NULL; for (match = strstr (class_list, class_name); match; match = strstr (match + 1, class_name)) { if ((match == class_list || g_ascii_isspace (match[-1])) && (match[len] == '\0' || g_ascii_isspace (match[len]))) return match; } return NULL; } static gboolean set_class_list (gchar **class_list, const gchar *new_class_list) { if (g_strcmp0 (*class_list, new_class_list) != 0) { g_free (*class_list); *class_list = g_strdup (new_class_list); return TRUE; } else return FALSE; } static gboolean add_class_name (gchar **class_list, const gchar *class_name) { gchar *new_class_list; if (*class_list) { if (find_class_name (*class_list, class_name)) return FALSE; new_class_list = g_strdup_printf ("%s %s", *class_list, class_name); g_free (*class_list); *class_list = new_class_list; } else *class_list = g_strdup (class_name); return TRUE; } static gboolean remove_class_name (gchar **class_list, const gchar *class_name) { const gchar *match, *end; gchar *new_class_list; if (!*class_list) return FALSE; if (strcmp (*class_list, class_name) == 0) { g_free (*class_list); *class_list = NULL; return TRUE; } match = find_class_name (*class_list, class_name); if (!match) return FALSE; end = match + strlen (class_name); /* Adjust either match or end to include a space as well. * (One or the other must be possible at this point.) */ if (match != *class_list) match--; else end++; new_class_list = g_strdup_printf ("%.*s%s", (int)(match - *class_list), *class_list, end); g_free (*class_list); *class_list = new_class_list; return TRUE; } /** * st_widget_set_style_class_name: * @actor: a #StWidget * @style_class_list: (nullable): a new style class list string * * Set the style class name list. @style_class_list can either be * %NULL, for no classes, or a space-separated list of style class * names. See also st_widget_add_style_class_name() and * st_widget_remove_style_class_name(). */ void st_widget_set_style_class_name (StWidget *actor, const gchar *style_class_list) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (actor)); priv = st_widget_get_instance_private (actor); if (set_class_list (&priv->style_class, style_class_list)) { st_widget_style_changed (actor); g_object_notify_by_pspec (G_OBJECT (actor), props[PROP_STYLE_CLASS]); } } /** * st_widget_add_style_class_name: * @actor: a #StWidget * @style_class: a style class name string * * Adds @style_class to @actor's style class name list, if it is not * already present. */ void st_widget_add_style_class_name (StWidget *actor, const gchar *style_class) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (actor)); g_return_if_fail (style_class != NULL); priv = st_widget_get_instance_private (actor); if (add_class_name (&priv->style_class, style_class)) { st_widget_style_changed (actor); g_object_notify_by_pspec (G_OBJECT (actor), props[PROP_STYLE_CLASS]); } } /** * st_widget_remove_style_class_name: * @actor: a #StWidget * @style_class: a style class name string * * Removes @style_class from @actor's style class name, if it is * present. */ void st_widget_remove_style_class_name (StWidget *actor, const gchar *style_class) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (actor)); g_return_if_fail (style_class != NULL); priv = st_widget_get_instance_private (actor); if (remove_class_name (&priv->style_class, style_class)) { st_widget_style_changed (actor); g_object_notify_by_pspec (G_OBJECT (actor), props[PROP_STYLE_CLASS]); } } /** * st_widget_get_style_class_name: * @actor: a #StWidget * * Get the current style class name * * Returns: the class name string. The string is owned by the #StWidget and * should not be modified or freed. */ const gchar* st_widget_get_style_class_name (StWidget *actor) { g_return_val_if_fail (ST_IS_WIDGET (actor), NULL); return ST_WIDGET_PRIVATE (actor)->style_class; } /** * st_widget_has_style_class_name: * @actor: a #StWidget * @style_class: a style class string * * Tests if @actor's style class list includes @style_class. * * Returns: whether or not @actor's style class list includes * @style_class. */ gboolean st_widget_has_style_class_name (StWidget *actor, const gchar *style_class) { StWidgetPrivate *priv; g_return_val_if_fail (ST_IS_WIDGET (actor), FALSE); priv = st_widget_get_instance_private (actor); return find_class_name (priv->style_class, style_class) != NULL; } /** * st_widget_get_style_pseudo_class: * @actor: a #StWidget * * Get the current style pseudo class list. * * Note that an actor can have multiple pseudo classes; if you just * want to test for the presence of a specific pseudo class, use * st_widget_has_style_pseudo_class(). * * Returns: the pseudo class list string. The string is owned by the * #StWidget and should not be modified or freed. */ const gchar* st_widget_get_style_pseudo_class (StWidget *actor) { g_return_val_if_fail (ST_IS_WIDGET (actor), NULL); return ST_WIDGET_PRIVATE (actor)->pseudo_class; } /** * st_widget_has_style_pseudo_class: * @actor: a #StWidget * @pseudo_class: a pseudo class string * * Tests if @actor's pseudo class list includes @pseudo_class. * * Returns: whether or not @actor's pseudo class list includes * @pseudo_class. */ gboolean st_widget_has_style_pseudo_class (StWidget *actor, const gchar *pseudo_class) { StWidgetPrivate *priv; g_return_val_if_fail (ST_IS_WIDGET (actor), FALSE); priv = st_widget_get_instance_private (actor); return find_class_name (priv->pseudo_class, pseudo_class) != NULL; } /** * st_widget_set_style_pseudo_class: * @actor: a #StWidget * @pseudo_class_list: (nullable): a new pseudo class list string * * Set the style pseudo class list. @pseudo_class_list can either be * %NULL, for no classes, or a space-separated list of pseudo class * names. See also st_widget_add_style_pseudo_class() and * st_widget_remove_style_pseudo_class(). */ void st_widget_set_style_pseudo_class (StWidget *actor, const gchar *pseudo_class_list) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (actor)); priv = st_widget_get_instance_private (actor); if (set_class_list (&priv->pseudo_class, pseudo_class_list)) { st_widget_style_changed (actor); g_object_notify_by_pspec (G_OBJECT (actor), props[PROP_PSEUDO_CLASS]); } } /** * st_widget_add_style_pseudo_class: * @actor: a #StWidget * @pseudo_class: a pseudo class string * * Adds @pseudo_class to @actor's pseudo class list, if it is not * already present. */ void st_widget_add_style_pseudo_class (StWidget *actor, const gchar *pseudo_class) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (actor)); g_return_if_fail (pseudo_class != NULL); priv = st_widget_get_instance_private (actor); if (add_class_name (&priv->pseudo_class, pseudo_class)) { st_widget_style_changed (actor); g_object_notify_by_pspec (G_OBJECT (actor), props[PROP_PSEUDO_CLASS]); } } /** * st_widget_remove_style_pseudo_class: * @actor: a #StWidget * @pseudo_class: a pseudo class string * * Removes @pseudo_class from @actor's pseudo class, if it is present. */ void st_widget_remove_style_pseudo_class (StWidget *actor, const gchar *pseudo_class) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (actor)); g_return_if_fail (pseudo_class != NULL); priv = st_widget_get_instance_private (actor); if (remove_class_name (&priv->pseudo_class, pseudo_class)) { st_widget_style_changed (actor); g_object_notify_by_pspec (G_OBJECT (actor), props[PROP_PSEUDO_CLASS]); } } /** * st_widget_set_style: * @actor: a #StWidget * @style: (nullable): a inline style string, or %NULL * * Set the inline style string for this widget. The inline style string is an * optional ';'-separated list of CSS properties that override the style as * determined from the stylesheets of the current theme. */ void st_widget_set_style (StWidget *actor, const gchar *style) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (actor)); priv = st_widget_get_instance_private (actor); if (g_strcmp0 (style, priv->inline_style)) { g_free (priv->inline_style); priv->inline_style = g_strdup (style); st_widget_style_changed (actor); g_object_notify_by_pspec (G_OBJECT (actor), props[PROP_STYLE]); } } /** * st_widget_get_style: * @actor: a #StWidget * * Get the current inline style string. See st_widget_set_style(). * * Returns: (transfer none) (nullable): The inline style string, or %NULL. The * string is owned by the #StWidget and should not be modified or freed. */ const gchar* st_widget_get_style (StWidget *actor) { g_return_val_if_fail (ST_IS_WIDGET (actor), NULL); return ST_WIDGET_PRIVATE (actor)->inline_style; } static void st_widget_set_first_visible_child (StWidget *widget, ClutterActor *actor) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); if (priv->first_visible_child == NULL && actor == NULL) return; if (priv->first_visible_child != NULL && CLUTTER_ACTOR (priv->first_visible_child) == actor) return; if (priv->first_visible_child != NULL) { st_widget_remove_style_pseudo_class (priv->first_visible_child, "first-child"); g_clear_object (&priv->first_visible_child); } if (actor == NULL) return; if (ST_IS_WIDGET (actor)) { st_widget_add_style_pseudo_class (ST_WIDGET (actor), "first-child"); priv->first_visible_child = g_object_ref (ST_WIDGET (actor)); } } static void st_widget_set_last_visible_child (StWidget *widget, ClutterActor *actor) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); if (priv->last_visible_child == NULL && actor == NULL) return; if (priv->last_visible_child != NULL && CLUTTER_ACTOR (priv->last_visible_child) == actor) return; if (priv->last_visible_child != NULL) { st_widget_remove_style_pseudo_class (priv->last_visible_child, "last-child"); g_clear_object (&priv->last_visible_child); } if (actor == NULL) return; if (ST_IS_WIDGET (actor)) { st_widget_add_style_pseudo_class (ST_WIDGET (actor), "last-child"); priv->last_visible_child = g_object_ref (ST_WIDGET (actor)); } } static void st_widget_name_notify (StWidget *widget, GParamSpec *pspec, gpointer data) { st_widget_style_changed (widget); } static void st_widget_reactive_notify (StWidget *widget, GParamSpec *pspec, gpointer data) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); if (clutter_actor_get_reactive (CLUTTER_ACTOR (widget))) st_widget_remove_style_pseudo_class (widget, "insensitive"); else st_widget_add_style_pseudo_class (widget, "insensitive"); if (priv->track_hover) st_widget_sync_hover(widget); } static ClutterActor * find_nearest_visible_backwards (ClutterActor *actor) { ClutterActor *prev = actor; while (prev != NULL && !clutter_actor_is_visible (prev)) prev = clutter_actor_get_previous_sibling (prev); return prev; } static ClutterActor * find_nearest_visible_forward (ClutterActor *actor) { ClutterActor *next = actor; while (next != NULL && !clutter_actor_is_visible (next)) next = clutter_actor_get_next_sibling (next); return next; } static gboolean st_widget_update_child_styles (StWidget *widget) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); if (priv->first_child_dirty) { ClutterActor *first_child; priv->first_child_dirty = FALSE; first_child = clutter_actor_get_first_child (CLUTTER_ACTOR (widget)); st_widget_set_first_visible_child (widget, find_nearest_visible_forward (first_child)); } if (priv->last_child_dirty) { ClutterActor *last_child; priv->last_child_dirty = FALSE; last_child = clutter_actor_get_last_child (CLUTTER_ACTOR (widget)); st_widget_set_last_visible_child (widget, find_nearest_visible_backwards (last_child)); } priv->update_child_styles_id = 0; return G_SOURCE_REMOVE; } static void st_widget_queue_child_styles_update (StWidget *widget) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); if (priv->update_child_styles_id != 0) return; priv->update_child_styles_id = g_idle_add ((GSourceFunc) st_widget_update_child_styles, widget); } static void st_widget_visible_notify (StWidget *widget, GParamSpec *pspec, gpointer data) { StWidgetPrivate *parent_priv; ClutterActor *actor = CLUTTER_ACTOR (widget); ClutterActor *parent = clutter_actor_get_parent (actor); if (parent == NULL || !ST_IS_WIDGET (parent)) return; parent_priv = st_widget_get_instance_private (ST_WIDGET (parent)); if (clutter_actor_is_visible (actor)) { ClutterActor *before, *after; before = clutter_actor_get_previous_sibling (actor); if (find_nearest_visible_backwards (before) == NULL) parent_priv->first_child_dirty = TRUE; after = clutter_actor_get_next_sibling (actor); if (find_nearest_visible_forward (after) == NULL) parent_priv->last_child_dirty = TRUE; } else { if (st_widget_has_style_pseudo_class (widget, "first-child")) parent_priv->first_child_dirty = TRUE; if (st_widget_has_style_pseudo_class (widget, "last-child")) parent_priv->last_child_dirty = TRUE; } if (parent_priv->first_child_dirty || parent_priv->last_child_dirty) st_widget_queue_child_styles_update (ST_WIDGET (parent)); } static void st_widget_first_child_notify (StWidget *widget, GParamSpec *pspec, gpointer data) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); priv->first_child_dirty = TRUE; st_widget_queue_child_styles_update (widget); } static void st_widget_last_child_notify (StWidget *widget, GParamSpec *pspec, gpointer data) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); priv->last_child_dirty = TRUE; st_widget_queue_child_styles_update (widget); } static void st_widget_init (StWidget *actor) { StWidgetPrivate *priv; guint i; priv = st_widget_get_instance_private (actor); priv->transition_animation = NULL; priv->local_state_set = atk_state_set_new (); /* connect style changed */ g_signal_connect (actor, "notify::name", G_CALLBACK (st_widget_name_notify), NULL); g_signal_connect (actor, "notify::reactive", G_CALLBACK (st_widget_reactive_notify), NULL); g_signal_connect (actor, "notify::visible", G_CALLBACK (st_widget_visible_notify), NULL); g_signal_connect (actor, "notify::first-child", G_CALLBACK (st_widget_first_child_notify), NULL); g_signal_connect (actor, "notify::last-child", G_CALLBACK (st_widget_last_child_notify), NULL); priv->texture_file_changed_id = g_signal_connect (st_texture_cache_get_default (), "texture-file-changed", G_CALLBACK (st_widget_texture_cache_changed), actor); for (i = 0; i < G_N_ELEMENTS (priv->paint_states); i++) st_theme_node_paint_state_init (&priv->paint_states[i]); } static void on_transition_completed (StThemeNodeTransition *transition, StWidget *widget) { next_paint_state (widget); st_theme_node_paint_state_copy (current_paint_state (widget), st_theme_node_transition_get_new_paint_state (transition)); st_widget_remove_transition (widget); } static void st_widget_recompute_style (StWidget *widget, StThemeNode *old_theme_node) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); StThemeNode *new_theme_node = st_widget_get_theme_node (widget); int transition_duration; StSettings *settings; gboolean paint_equal, geometry_equal = FALSE; gboolean animations_enabled; if (new_theme_node == old_theme_node) { priv->is_style_dirty = FALSE; return; } _st_theme_node_apply_margins (new_theme_node, CLUTTER_ACTOR (widget)); if (old_theme_node) geometry_equal = st_theme_node_geometry_equal (old_theme_node, new_theme_node); if (!geometry_equal) clutter_actor_queue_relayout ((ClutterActor *) widget); transition_duration = st_theme_node_get_transition_duration (new_theme_node); paint_equal = st_theme_node_paint_equal (old_theme_node, new_theme_node); settings = st_settings_get (); g_object_get (settings, "enable-animations", &animations_enabled, NULL); if (animations_enabled && transition_duration > 0) { if (priv->transition_animation != NULL) { st_theme_node_transition_update (priv->transition_animation, new_theme_node); } else if (old_theme_node && !paint_equal) { /* Since our transitions are only of the painting done by StThemeNode, we * only want to start a transition when what is painted changes; if * other visual aspects like the foreground color of a label change, * we can't animate that anyways. */ priv->transition_animation = st_theme_node_transition_new (CLUTTER_ACTOR (widget), old_theme_node, new_theme_node, current_paint_state (widget), transition_duration); g_signal_connect (priv->transition_animation, "completed", G_CALLBACK (on_transition_completed), widget); g_signal_connect_swapped (priv->transition_animation, "new-frame", G_CALLBACK (clutter_actor_queue_redraw), widget); } } else if (priv->transition_animation) { st_widget_remove_transition (widget); } if (!paint_equal) { next_paint_state (widget); if (!st_theme_node_paint_equal (new_theme_node, current_paint_state (widget)->node)) st_theme_node_paint_state_invalidate (current_paint_state (widget)); } /* It is very likely that custom CSS properties are used with StDrawingArea to control the custom drawing, so never omit the ::style-changed signal */ if (paint_equal) paint_equal = !ST_IS_DRAWING_AREA (widget); if (paint_equal && old_theme_node->font_desc != NULL) paint_equal = pango_font_description_equal (old_theme_node->font_desc, st_theme_node_get_font (new_theme_node)); if (paint_equal && old_theme_node->foreground_computed) { ClutterColor col; st_theme_node_get_foreground_color (new_theme_node, &col); paint_equal = clutter_color_equal (&old_theme_node->foreground_color, &col); } if (paint_equal && old_theme_node->icon_colors) paint_equal = st_icon_colors_equal (old_theme_node->icon_colors, st_theme_node_get_icon_colors (new_theme_node)); if (!paint_equal || !geometry_equal) g_signal_emit (widget, signals[STYLE_CHANGED], 0); priv->is_style_dirty = FALSE; } /** * st_widget_ensure_style: * @widget: A #StWidget * * Ensures that @widget has read its style information and propagated any * changes to its children. */ void st_widget_ensure_style (StWidget *widget) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (widget)); priv = st_widget_get_instance_private (widget); if (priv->is_style_dirty) { st_widget_recompute_style (widget, NULL); notify_children_of_style_change (CLUTTER_ACTOR (widget)); } } /** * st_widget_set_track_hover: * @widget: A #StWidget * @track_hover: %TRUE if the widget should track the pointer hover state * * Enables hover tracking on the #StWidget. * * If hover tracking is enabled, and the widget is visible and * reactive, then @widget's #StWidget:hover property will be updated * automatically to reflect whether the pointer is in @widget (or one * of its children), and @widget's #StWidget:pseudo-class will have * the "hover" class added and removed from it accordingly. * * Note that currently it is not possible to correctly track the hover * state when another actor has a pointer grab. You can use * st_widget_sync_hover() to update the property manually in this * case. */ void st_widget_set_track_hover (StWidget *widget, gboolean track_hover) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (widget)); priv = st_widget_get_instance_private (widget); if (priv->track_hover != track_hover) { priv->track_hover = track_hover; g_object_notify_by_pspec (G_OBJECT (widget), props[PROP_TRACK_HOVER]); if (priv->track_hover) st_widget_sync_hover (widget); else st_widget_set_hover (widget, FALSE); } } /** * st_widget_get_track_hover: * @widget: A #StWidget * * Returns the current value of the #StWidget:track-hover property. See * st_widget_set_track_hover() for more information. * * Returns: current value of track-hover on @widget */ gboolean st_widget_get_track_hover (StWidget *widget) { g_return_val_if_fail (ST_IS_WIDGET (widget), FALSE); return ST_WIDGET_PRIVATE (widget)->track_hover; } /** * st_widget_set_hover: * @widget: A #StWidget * @hover: whether the pointer is hovering over the widget * * Sets @widget's hover property and adds or removes "hover" from its * pseudo class accordingly. * * If you have set #StWidget:track-hover, you should not need to call * this directly. You can call st_widget_sync_hover() if the hover * state might be out of sync due to another actor's pointer grab. */ void st_widget_set_hover (StWidget *widget, gboolean hover) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (widget)); priv = st_widget_get_instance_private (widget); if (priv->hover != hover) { priv->hover = hover; if (priv->hover) st_widget_add_style_pseudo_class (widget, "hover"); else st_widget_remove_style_pseudo_class (widget, "hover"); g_object_notify_by_pspec (G_OBJECT (widget), props[PROP_HOVER]); } } /** * st_widget_sync_hover: * @widget: A #StWidget * * Sets @widget's hover state according to the current pointer * position. This can be used to ensure that it is correct after * (or during) a pointer grab. */ void st_widget_sync_hover (StWidget *widget) { ClutterInputDevice *pointer; ClutterActor *pointer_actor; ClutterSeat *seat; seat = clutter_backend_get_default_seat (clutter_get_default_backend ()); pointer = clutter_seat_get_pointer (seat); pointer_actor = clutter_input_device_get_actor (pointer, NULL); if (pointer_actor && clutter_actor_get_reactive (CLUTTER_ACTOR (widget))) st_widget_set_hover (widget, clutter_actor_contains (CLUTTER_ACTOR (widget), pointer_actor)); else st_widget_set_hover (widget, FALSE); } /** * st_widget_get_hover: * @widget: A #StWidget * * If #StWidget:track-hover is set, this returns whether the pointer * is currently over the widget. * * Returns: current value of hover on @widget */ gboolean st_widget_get_hover (StWidget *widget) { g_return_val_if_fail (ST_IS_WIDGET (widget), FALSE); return ST_WIDGET_PRIVATE (widget)->hover; } /** * st_widget_set_can_focus: * @widget: A #StWidget * @can_focus: %TRUE if the widget can receive keyboard focus * via keyboard navigation * * Marks @widget as being able to receive keyboard focus via * keyboard navigation. */ void st_widget_set_can_focus (StWidget *widget, gboolean can_focus) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (widget)); priv = st_widget_get_instance_private (widget); if (priv->can_focus != can_focus) { priv->can_focus = can_focus; g_object_notify_by_pspec (G_OBJECT (widget), props[PROP_CAN_FOCUS]); } } /** * st_widget_get_can_focus: * @widget: A #StWidget * * Returns the current value of the can-focus property. See * st_widget_set_can_focus() for more information. * * Returns: current value of can-focus on @widget */ gboolean st_widget_get_can_focus (StWidget *widget) { g_return_val_if_fail (ST_IS_WIDGET (widget), FALSE); return ST_WIDGET_PRIVATE (widget)->can_focus; } /** * st_widget_popup_menu: * @self: A #StWidget * * Asks the widget to pop-up a context menu by emitting #StWidget::popup-menu. */ void st_widget_popup_menu (StWidget *self) { g_signal_emit (self, signals[POPUP_MENU], 0); } /* filter @children to contain only only actors that overlap @rbox * when moving in @direction. (Assuming no transformations.) */ static GList * filter_by_position (GList *children, ClutterActorBox *rbox, StDirectionType direction) { ClutterActorBox cbox; graphene_point3d_t abs_vertices[4]; GList *l, *ret; ClutterActor *child; for (l = children, ret = NULL; l; l = l->next) { child = l->data; clutter_actor_get_abs_allocation_vertices (child, abs_vertices); clutter_actor_box_from_vertices (&cbox, abs_vertices); /* Filter out children if they are in the wrong direction from * @rbox, or if they don't overlap it. To account for floating- * point imprecision, an actor is "down" (etc.) from an another * actor even if it overlaps it by up to 0.1 pixels. */ switch (direction) { case ST_DIR_UP: if (cbox.y2 > rbox->y1 + 0.1) continue; break; case ST_DIR_DOWN: if (cbox.y1 < rbox->y2 - 0.1) continue; break; case ST_DIR_LEFT: if (cbox.x2 > rbox->x1 + 0.1) continue; break; case ST_DIR_RIGHT: if (cbox.x1 < rbox->x2 - 0.1) continue; break; case ST_DIR_TAB_BACKWARD: case ST_DIR_TAB_FORWARD: default: g_return_val_if_reached (NULL); } ret = g_list_prepend (ret, child); } g_list_free (children); return ret; } static void get_midpoint (ClutterActorBox *box, int *x, int *y) { *x = (box->x1 + box->x2) / 2; *y = (box->y1 + box->y2) / 2; } static double get_distance (ClutterActor *actor, ClutterActorBox *bbox) { int ax, ay, bx, by, dx, dy; ClutterActorBox abox; graphene_point3d_t abs_vertices[4]; clutter_actor_get_abs_allocation_vertices (actor, abs_vertices); clutter_actor_box_from_vertices (&abox, abs_vertices); get_midpoint (&abox, &ax, &ay); get_midpoint (bbox, &bx, &by); dx = ax - bx; dy = ay - by; /* Not the exact distance, but good enough to sort by. */ return dx*dx + dy*dy; } static int sort_by_distance (gconstpointer a, gconstpointer b, gpointer user_data) { ClutterActor *actor_a = (ClutterActor *)a; ClutterActor *actor_b = (ClutterActor *)b; ClutterActorBox *box = user_data; return get_distance (actor_a, box) - get_distance (actor_b, box); } static gboolean st_widget_real_navigate_focus (StWidget *widget, ClutterActor *from, StDirectionType direction) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); ClutterActor *widget_actor, *focus_child; GList *children, *l; widget_actor = CLUTTER_ACTOR (widget); if (from == widget_actor) return FALSE; /* Figure out if @from is a descendant of @widget, and if so, * set @focus_child to the immediate child of @widget that * contains (or *is*) @from. */ focus_child = from; while (focus_child && clutter_actor_get_parent (focus_child) != widget_actor) focus_child = clutter_actor_get_parent (focus_child); if (priv->can_focus) { if (!focus_child) { if (clutter_actor_is_mapped (widget_actor)) { /* Accept focus from outside */ clutter_actor_grab_key_focus (widget_actor); return TRUE; } else { /* Refuse to set focus on hidden actors */ return FALSE; } } else { /* Yield focus from within: since @widget itself is * focusable we don't allow the focus to be navigated * within @widget. */ return FALSE; } } /* See if we can navigate within @focus_child */ if (focus_child && ST_IS_WIDGET (focus_child)) { if (st_widget_navigate_focus (ST_WIDGET (focus_child), from, direction, FALSE)) return TRUE; } children = st_widget_get_focus_chain (widget); if (direction == ST_DIR_TAB_FORWARD || direction == ST_DIR_TAB_BACKWARD) { /* At this point we know that we want to navigate focus to one of * @widget's immediate children; the next one after @focus_child, or the * first one if @focus_child is %NULL. (With "next" and "first" being * determined by @direction.) */ if (direction == ST_DIR_TAB_BACKWARD) children = g_list_reverse (children); if (focus_child) { /* Remove focus_child and any earlier children */ while (children && children->data != focus_child) children = g_list_delete_link (children, children); if (children) children = g_list_delete_link (children, children); } } else /* direction is an arrow key, not tab */ { ClutterActorBox sort_box; graphene_point3d_t abs_vertices[4]; /* Compute the allocation box of the previous focused actor. If there * was no previous focus, use the coordinates of the appropriate edge of * @widget. * * Note that all of this code assumes the actors are not * transformed (or at most, they are all scaled by the same * amount). If @widget or any of its children is rotated, or * any child is inconsistently scaled, then the focus chain will * probably be unpredictable. */ if (from) { clutter_actor_get_abs_allocation_vertices (from, abs_vertices); clutter_actor_box_from_vertices (&sort_box, abs_vertices); } else { clutter_actor_get_abs_allocation_vertices (widget_actor, abs_vertices); clutter_actor_box_from_vertices (&sort_box, abs_vertices); switch (direction) { case ST_DIR_UP: sort_box.y1 = sort_box.y2; break; case ST_DIR_DOWN: sort_box.y2 = sort_box.y1; break; case ST_DIR_LEFT: sort_box.x1 = sort_box.x2; break; case ST_DIR_RIGHT: sort_box.x2 = sort_box.x1; break; case ST_DIR_TAB_FORWARD: case ST_DIR_TAB_BACKWARD: default: g_warn_if_reached (); } } if (from) children = filter_by_position (children, &sort_box, direction); if (children) children = g_list_sort_with_data (children, sort_by_distance, &sort_box); } /* Now try each child in turn */ for (l = children; l; l = l->next) { if (ST_IS_WIDGET (l->data)) { if (st_widget_navigate_focus (l->data, from, direction, FALSE)) { g_list_free (children); return TRUE; } } } g_list_free (children); return FALSE; } /** * st_widget_navigate_focus: * @widget: the "top level" container * @from: (nullable): the actor that the focus is coming from * @direction: the direction focus is moving in * @wrap_around: whether focus should wrap around * * Tries to update the keyboard focus within @widget in response to a * keyboard event. * * If @from is a descendant of @widget, this attempts to move the * keyboard focus to the next descendant of @widget (in the order * implied by @direction) that has the #StWidget:can-focus property * set. If @from is %NULL, this attempts to focus either @widget * itself, or its first descendant in the order implied by * @direction. If @from is outside of @widget, it behaves as if it was * a descendant if @direction is one of the directional arrows and as * if it was %NULL otherwise. * * If a container type is marked #StWidget:can-focus, the expected * behavior is that it will only take up a single slot on the focus * chain as a whole, rather than allowing navigation between its child * actors (or having a distinction between itself being focused and * one of its children being focused). * * Some widget classes might have slightly different behavior from the * above, where that would make more sense. * * If @wrap_around is %TRUE and @from is a child of @widget, but the * widget has no further children that can accept the focus in the * given direction, then st_widget_navigate_focus() will try a second * time, using a %NULL @from, which should cause it to reset the focus * to the first available widget in the given direction. * * Returns: %TRUE if clutter_actor_grab_key_focus() has been * called on an actor. %FALSE if not. */ gboolean st_widget_navigate_focus (StWidget *widget, ClutterActor *from, StDirectionType direction, gboolean wrap_around) { g_return_val_if_fail (ST_IS_WIDGET (widget), FALSE); if (ST_WIDGET_GET_CLASS (widget)->navigate_focus (widget, from, direction)) return TRUE; if (wrap_around && from && clutter_actor_contains (CLUTTER_ACTOR (widget), from)) return ST_WIDGET_GET_CLASS (widget)->navigate_focus (widget, NULL, direction); return FALSE; } static gboolean append_actor_text (GString *desc, ClutterActor *actor) { if (CLUTTER_IS_TEXT (actor)) { g_string_append_printf (desc, " (\"%s\")", clutter_text_get_text (CLUTTER_TEXT (actor))); return TRUE; } else if (ST_IS_LABEL (actor)) { g_string_append_printf (desc, " (\"%s\")", st_label_get_text (ST_LABEL (actor))); return TRUE; } else return FALSE; } /** * st_describe_actor: * @actor: a #ClutterActor * * Creates a string describing @actor, for use in debugging. This * includes the class name and actor name (if any), plus if @actor * is an #StWidget, its style class and pseudo class names. * * Returns: the debug name. */ char * st_describe_actor (ClutterActor *actor) { GString *desc; const char *name; int i; if (!actor) return g_strdup ("[null]"); desc = g_string_new (NULL); g_string_append_printf (desc, "[%p %s", actor, G_OBJECT_TYPE_NAME (actor)); if (ST_IS_WIDGET (actor)) { const char *style_class = st_widget_get_style_class_name (ST_WIDGET (actor)); const char *pseudo_class = st_widget_get_style_pseudo_class (ST_WIDGET (actor)); char **classes; if (style_class) { classes = g_strsplit (style_class, ",", -1); for (i = 0; classes[i]; i++) { g_strchug (classes[i]); g_string_append_printf (desc, ".%s", classes[i]); } g_strfreev (classes); } if (pseudo_class) { classes = g_strsplit (pseudo_class, ",", -1); for (i = 0; classes[i]; i++) { g_strchug (classes[i]); g_string_append_printf (desc, ":%s", classes[i]); } g_strfreev (classes); } } name = clutter_actor_get_name (actor); if (name) g_string_append_printf (desc, " \"%s\"", name); if (!append_actor_text (desc, actor)) { GList *children, *l; /* Do a limited search of @actor's children looking for a label */ children = clutter_actor_get_children (actor); for (l = children, i = 0; l && i < 20; l = l->next, i++) { if (append_actor_text (desc, l->data)) break; children = g_list_concat (children, clutter_actor_get_children (l->data)); } g_list_free (children); } g_string_append_c (desc, ']'); return g_string_free (desc, FALSE); } /** * st_widget_get_label_actor: * @widget: a #StWidget * * Gets the label that identifies @widget if it is defined * * Returns: (transfer none): the label that identifies the widget */ ClutterActor * st_widget_get_label_actor (StWidget *widget) { g_return_val_if_fail (ST_IS_WIDGET (widget), NULL); return ST_WIDGET_PRIVATE (widget)->label_actor; } /** * st_widget_set_label_actor: * @widget: a #StWidget * @label: a #ClutterActor * * Sets @label as the #ClutterActor that identifies (labels) * @widget. @label can be %NULL to indicate that @widget is not * labelled any more */ void st_widget_set_label_actor (StWidget *widget, ClutterActor *label) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (widget)); priv = st_widget_get_instance_private (widget); if (priv->label_actor != label) { if (priv->label_actor) g_object_unref (priv->label_actor); if (label != NULL) priv->label_actor = g_object_ref (label); else priv->label_actor = NULL; g_object_notify_by_pspec (G_OBJECT (widget), props[PROP_LABEL_ACTOR]); } } /** * st_widget_set_accessible_name: * @widget: widget to set the accessible name for * @name: (nullable): a character string to be set as the accessible name * * This method sets @name as the accessible name for @widget. * * Usually you will have no need to set the accessible name for an * object, as usually there is a label for most of the interface * elements. So in general it is better to just use * @st_widget_set_label_actor. This method is only required when you * need to set an accessible name and there is no available label * object. * */ void st_widget_set_accessible_name (StWidget *widget, const gchar *name) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (widget)); priv = st_widget_get_instance_private (widget); if (priv->accessible_name != NULL) g_free (priv->accessible_name); priv->accessible_name = g_strdup (name); g_object_notify_by_pspec (G_OBJECT (widget), props[PROP_ACCESSIBLE_NAME]); } /** * st_widget_get_accessible_name: * @widget: widget to get the accessible name for * * Gets the accessible name for this widget. See * st_widget_set_accessible_name() for more information. * * Returns: a character string representing the accessible name * of the widget. */ const gchar * st_widget_get_accessible_name (StWidget *widget) { g_return_val_if_fail (ST_IS_WIDGET (widget), NULL); return ST_WIDGET_PRIVATE (widget)->accessible_name; } /** * st_widget_set_accessible_role: * @widget: widget to set the accessible role for * @role: The role to use * * This method sets @role as the accessible role for @widget. This * role describes what kind of user interface element @widget is and * is provided so that assistive technologies know how to present * @widget to the user. * * Usually you will have no need to set the accessible role for an * object, as this information is extracted from the context of the * object (ie: a #StButton has by default a push button role). This * method is only required when you need to redefine the role * currently associated with the widget, for instance if it is being * used in an unusual way (ie: a #StButton used as a togglebutton), or * if a generic object is used directly (ie: a container as a menu * item). * * If @role is #ATK_ROLE_INVALID, the role will not be changed * and the accessible's default role will be used instead. */ void st_widget_set_accessible_role (StWidget *widget, AtkRole role) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (widget)); priv = st_widget_get_instance_private (widget); priv->accessible_role = role; g_object_notify_by_pspec (G_OBJECT (widget), props[PROP_ACCESSIBLE_ROLE]); } /** * st_widget_get_accessible_role: * @widget: widget to get the accessible role for * * Gets the #AtkRole for this widget. See * st_widget_set_accessible_role() for more information. * * Returns: accessible #AtkRole for this widget */ AtkRole st_widget_get_accessible_role (StWidget *widget) { StWidgetPrivate *priv; AtkRole role = ATK_ROLE_INVALID; g_return_val_if_fail (ST_IS_WIDGET (widget), ATK_ROLE_INVALID); priv = st_widget_get_instance_private (widget); if (priv->accessible_role != ATK_ROLE_INVALID) role = priv->accessible_role; else if (priv->accessible != NULL) role = atk_object_get_role (priv->accessible); return role; } static void notify_accessible_state_change (StWidget *widget, AtkStateType state, gboolean value) { StWidgetPrivate *priv = st_widget_get_instance_private (widget); if (priv->accessible != NULL) atk_object_notify_state_change (priv->accessible, state, value); } /** * st_widget_add_accessible_state: * @widget: A #StWidget * @state: #AtkStateType state to add * * This method adds @state as one of the accessible states for * @widget. The list of states of a widget describes the current state * of user interface element @widget and is provided so that assistive * technologies know how to present @widget to the user. * * Usually you will have no need to add accessible states for an * object, as the accessible object can extract most of the states * from the object itself (ie: a #StButton knows when it is pressed). * This method is only required when one cannot extract the * information automatically from the object itself (i.e.: a generic * container used as a toggle menu item will not automatically include * the toggled state). * */ void st_widget_add_accessible_state (StWidget *widget, AtkStateType state) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (widget)); priv = st_widget_get_instance_private (widget); if (atk_state_set_add_state (priv->local_state_set, state)) notify_accessible_state_change (widget, state, TRUE); } /** * st_widget_remove_accessible_state: * @widget: A #StWidget * @state: #AtkState state to remove * * This method removes @state as on of the accessible states for * @widget. See st_widget_add_accessible_state() for more information. * */ void st_widget_remove_accessible_state (StWidget *widget, AtkStateType state) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (widget)); priv = st_widget_get_instance_private (widget); if (atk_state_set_remove_state (priv->local_state_set, state)) notify_accessible_state_change (widget, state, FALSE); } /******************************************************************************/ /*************************** ACCESSIBILITY SUPPORT ****************************/ /******************************************************************************/ /* GObject */ static void st_widget_accessible_dispose (GObject *gobject); /* AtkObject */ static AtkStateSet *st_widget_accessible_ref_state_set (AtkObject *obj); static void st_widget_accessible_initialize (AtkObject *obj, gpointer data); static AtkRole st_widget_accessible_get_role (AtkObject *obj); /* Private methods */ static void on_pseudo_class_notify (GObject *gobject, GParamSpec *pspec, gpointer data); static void on_can_focus_notify (GObject *gobject, GParamSpec *pspec, gpointer data); static void on_label_notify (GObject *gobject, GParamSpec *pspec, gpointer data); static void check_pseudo_class (StWidgetAccessible *self, StWidget *widget); static void check_labels (StWidgetAccessible *self, StWidget *widget); struct _StWidgetAccessiblePrivate { /* Cached values (used to avoid extra notifications) */ gboolean selected; gboolean checked; /* The current_label. Right now there are the proper atk * relationships between this object and the label */ AtkObject *current_label; }; G_DEFINE_TYPE_WITH_PRIVATE (StWidgetAccessible, st_widget_accessible, CALLY_TYPE_ACTOR) static gboolean st_widget_has_accessible (ClutterActor *actor) { StWidget *widget; StWidgetPrivate *priv; g_return_val_if_fail (ST_IS_WIDGET (actor), FALSE); widget = ST_WIDGET (actor); priv = st_widget_get_instance_private (widget); return priv->accessible != NULL; } static AtkObject * st_widget_get_accessible (ClutterActor *actor) { StWidget *widget = NULL; StWidgetPrivate *priv; g_return_val_if_fail (ST_IS_WIDGET (actor), NULL); widget = ST_WIDGET (actor); priv = st_widget_get_instance_private (widget); if (priv->accessible == NULL) { priv->accessible = g_object_new (ST_WIDGET_GET_CLASS (widget)->get_accessible_type (), NULL); atk_object_initialize (priv->accessible, actor); /* AtkGObjectAccessible, which StWidgetAccessible derives from, clears * the back reference to the object in a weak notify for the object; * weak-ref notification, which occurs during g_object_real_dispose(), * is then the optimal time to clear the forward reference. We * can't clear the reference in dispose() before chaining up, since * clutter_actor_dispose() causes notifications to be sent out, which * will result in a new accessible object being created. */ g_object_add_weak_pointer (G_OBJECT (actor), (gpointer *)&priv->accessible); } return priv->accessible; } /** * st_widget_set_accessible: * @widget: A #StWidget * @accessible: an accessible (#AtkObject) * * This method allows to set a customly created accessible object to * this widget. For example if you define a new subclass of * #StWidgetAccessible at the javascript code. * * NULL is a valid value for @accessible. That contemplates the * hypothetical case of not needing anymore a custom accessible object * for the widget. Next call of st_widget_get_accessible() would * create and return a default accessible. * * It assumes that the call to atk_object_initialize that bound the * gobject with the custom accessible object was already called, so * not a responsibility of this method. * */ void st_widget_set_accessible (StWidget *widget, AtkObject *accessible) { StWidgetPrivate *priv; g_return_if_fail (ST_IS_WIDGET (widget)); g_return_if_fail (accessible == NULL || ATK_IS_GOBJECT_ACCESSIBLE (accessible)); priv = st_widget_get_instance_private (widget); if (priv->accessible != accessible) { if (priv->accessible) { g_object_remove_weak_pointer (G_OBJECT (widget), (gpointer *)&priv->accessible); g_object_unref (priv->accessible); priv->accessible = NULL; } if (accessible) { priv->accessible = g_object_ref (accessible); /* See note in st_widget_get_accessible() */ g_object_add_weak_pointer (G_OBJECT (widget), (gpointer *)&priv->accessible); } else priv->accessible = NULL; } } static const gchar * st_widget_accessible_get_name (AtkObject *obj) { const gchar* name = NULL; g_return_val_if_fail (ST_IS_WIDGET_ACCESSIBLE (obj), NULL); name = ATK_OBJECT_CLASS (st_widget_accessible_parent_class)->get_name (obj); if (name == NULL) { StWidget *widget = NULL; widget = ST_WIDGET (atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (obj))); if (widget == NULL) name = NULL; else name = st_widget_get_accessible_name (widget); } return name; } static void st_widget_accessible_class_init (StWidgetAccessibleClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); AtkObjectClass *atk_class = ATK_OBJECT_CLASS (klass); gobject_class->dispose = st_widget_accessible_dispose; atk_class->ref_state_set = st_widget_accessible_ref_state_set; atk_class->initialize = st_widget_accessible_initialize; atk_class->get_role = st_widget_accessible_get_role; atk_class->get_name = st_widget_accessible_get_name; } static void st_widget_accessible_init (StWidgetAccessible *self) { StWidgetAccessiblePrivate *priv = st_widget_accessible_get_instance_private (self); self->priv = priv; } static void st_widget_accessible_dispose (GObject *gobject) { StWidgetAccessible *self = ST_WIDGET_ACCESSIBLE (gobject); if (self->priv->current_label) { g_object_unref (self->priv->current_label); self->priv->current_label = NULL; } G_OBJECT_CLASS (st_widget_accessible_parent_class)->dispose (gobject); } static void on_accessible_name_notify (GObject *gobject, GParamSpec *pspec, AtkObject *accessible) { g_object_notify (G_OBJECT (accessible), "accessible-name"); } static void st_widget_accessible_initialize (AtkObject *obj, gpointer data) { ATK_OBJECT_CLASS (st_widget_accessible_parent_class)->initialize (obj, data); g_signal_connect (data, "notify::pseudo-class", G_CALLBACK (on_pseudo_class_notify), obj); g_signal_connect (data, "notify::can-focus", G_CALLBACK (on_can_focus_notify), obj); g_signal_connect (data, "notify::label-actor", G_CALLBACK (on_label_notify), obj); g_signal_connect (data, "notify::accessible-name", G_CALLBACK (on_accessible_name_notify), obj); /* Check the cached selected state and notify the first selection. * Ie: it is required to ensure a first notification when Alt+Tab * popup appears */ check_pseudo_class (ST_WIDGET_ACCESSIBLE (obj), ST_WIDGET (data)); check_labels (ST_WIDGET_ACCESSIBLE (obj), ST_WIDGET (data)); } static AtkStateSet * st_widget_accessible_ref_state_set (AtkObject *obj) { AtkStateSet *result = NULL; AtkStateSet *aux_set = NULL; ClutterActor *actor = NULL; StWidget *widget = NULL; StWidgetPrivate *widget_priv; StWidgetAccessible *self = NULL; result = ATK_OBJECT_CLASS (st_widget_accessible_parent_class)->ref_state_set (obj); actor = CLUTTER_ACTOR (atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (obj))); if (actor == NULL) /* State is defunct */ return result; widget = ST_WIDGET (actor); self = ST_WIDGET_ACCESSIBLE (obj); widget_priv = st_widget_get_instance_private (widget); /* priv->selected should be properly updated on the * ATK_STATE_SELECTED notification callbacks */ if (self->priv->selected) atk_state_set_add_state (result, ATK_STATE_SELECTED); if (self->priv->checked) atk_state_set_add_state (result, ATK_STATE_CHECKED); /* On clutter there isn't any tip to know if a actor is focusable or * not, anyone can receive the key_focus. For this reason * cally_actor sets any actor as FOCUSABLE. This is not the case on * St, where we have can_focus. But this means that we need to * remove the state FOCUSABLE if it is not focusable */ if (st_widget_get_can_focus (widget)) atk_state_set_add_state (result, ATK_STATE_FOCUSABLE); else atk_state_set_remove_state (result, ATK_STATE_FOCUSABLE); /* We add the states added externally if required */ if (!atk_state_set_is_empty (widget_priv->local_state_set)) { aux_set = atk_state_set_or_sets (result, widget_priv->local_state_set); g_object_unref (result); /* previous result will not be used */ result = aux_set; } return result; } static AtkRole st_widget_accessible_get_role (AtkObject *obj) { StWidget *widget = NULL; StWidgetPrivate *priv; g_return_val_if_fail (ST_IS_WIDGET_ACCESSIBLE (obj), ATK_ROLE_INVALID); widget = ST_WIDGET (atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (obj))); if (widget == NULL) return ATK_ROLE_INVALID; priv = st_widget_get_instance_private (widget); if (priv->accessible_role != ATK_ROLE_INVALID) return priv->accessible_role; return ATK_OBJECT_CLASS (st_widget_accessible_parent_class)->get_role (obj); } static void on_pseudo_class_notify (GObject *gobject, GParamSpec *pspec, gpointer data) { check_pseudo_class (ST_WIDGET_ACCESSIBLE (data), ST_WIDGET (gobject)); } /* * In some cases the only way to check some states are checking the * pseudo-class. Like if the object is selected (see bug 637830) or if * the object is toggled. This method also notifies a state change if * the value is different to the one cached. * * We also assume that if the object uses that pseudo-class, it makes * sense to notify that state change. It would be possible to refine * that behaviour checking the role (ie: notify CHECKED changes only * for CHECK_BUTTON roles). * * In a ideal world we would have a more standard way to get the * state, like the widget-context (as in the case of * gtktreeview-cells), or something like the property "can-focus". But * for the moment this is enough, and we can update that in the future * if required. */ static void check_pseudo_class (StWidgetAccessible *self, StWidget *widget) { gboolean found = FALSE; found = st_widget_has_style_pseudo_class (widget, "selected"); if (found != self->priv->selected) { self->priv->selected = found; atk_object_notify_state_change (ATK_OBJECT (self), ATK_STATE_SELECTED, found); } found = st_widget_has_style_pseudo_class (widget, "checked"); if (found != self->priv->checked) { self->priv->checked = found; atk_object_notify_state_change (ATK_OBJECT (self), ATK_STATE_CHECKED, found); } } static void on_can_focus_notify (GObject *gobject, GParamSpec *pspec, gpointer data) { gboolean can_focus = st_widget_get_can_focus (ST_WIDGET (gobject)); atk_object_notify_state_change (ATK_OBJECT (data), ATK_STATE_FOCUSABLE, can_focus); } static void on_label_notify (GObject *gobject, GParamSpec *pspec, gpointer data) { check_labels (ST_WIDGET_ACCESSIBLE (data), ST_WIDGET (gobject)); } static void check_labels (StWidgetAccessible *widget_accessible, StWidget *widget) { ClutterActor *label = NULL; AtkObject *label_accessible = NULL; /* We only call this method at startup, and when the label changes, * so it is fine to remove the previous relationships if we have the * current_label by default */ if (widget_accessible->priv->current_label != NULL) { AtkObject *previous_label = widget_accessible->priv->current_label; atk_object_remove_relationship (ATK_OBJECT (widget_accessible), ATK_RELATION_LABELLED_BY, previous_label); atk_object_remove_relationship (previous_label, ATK_RELATION_LABEL_FOR, ATK_OBJECT (widget_accessible)); g_object_unref (previous_label); } label = st_widget_get_label_actor (widget); if (label == NULL) { widget_accessible->priv->current_label = NULL; } else { label_accessible = clutter_actor_get_accessible (label); widget_accessible->priv->current_label = g_object_ref (label_accessible); atk_object_add_relationship (ATK_OBJECT (widget_accessible), ATK_RELATION_LABELLED_BY, label_accessible); atk_object_add_relationship (label_accessible, ATK_RELATION_LABEL_FOR, ATK_OBJECT (widget_accessible)); } } /** * st_widget_get_focus_chain: * @widget: An #StWidget * * Gets a list of the focusable children of @widget, in "Tab" * order. By default, this returns all visible * (as in clutter_actor_is_visible()) children of @widget. * * Returns: (element-type Clutter.Actor) (transfer container): * @widget's focusable children */ GList * st_widget_get_focus_chain (StWidget *widget) { return ST_WIDGET_GET_CLASS (widget)->get_focus_chain (widget); }