static void
st_container_update_pseudo_classes (StContainer *container)
{
GList *first_item, *last_item;
ClutterActor *first_child, *last_child;
StContainerPrivate *priv = container->priv;
if (priv->block_update_pseudo_classes)
return;
first_item = priv->children;
first_child = first_item ? first_item->data : NULL;
if (first_child != priv->first_child)
{
if (priv->first_child && ST_IS_WIDGET (priv->first_child))
st_widget_remove_style_pseudo_class (ST_WIDGET (priv->first_child),
"first-child");
if (priv->first_child)
{
g_object_unref (priv->first_child);
priv->first_child = NULL;
}
if (first_child && ST_IS_WIDGET (first_child))
st_widget_add_style_pseudo_class (ST_WIDGET (first_child),
"first-child");
if (first_child)
priv->first_child = g_object_ref (first_child);
}
last_item = g_list_last (priv->children);
last_child = last_item ? last_item->data : NULL;
if (last_child != priv->last_child)
{
if (priv->last_child && ST_IS_WIDGET (priv->last_child))
st_widget_remove_style_pseudo_class (ST_WIDGET (priv->last_child),
"last-child");
if (priv->last_child)
{
g_object_unref (priv->last_child);
priv->last_child = NULL;
}
if (last_child && ST_IS_WIDGET (last_child))
st_widget_add_style_pseudo_class (ST_WIDGET (last_child),
"last-child");
if (last_child)
priv->last_child = g_object_ref (last_child);
}
}
/**
* st_entry_set_text:
* @entry: a #StEntry
* @text: (allow-none): text to set the entry to
*
* Sets the text displayed on the entry
*/
void
st_entry_set_text (StEntry *entry,
const gchar *text)
{
StEntryPrivate *priv;
g_return_if_fail (ST_IS_ENTRY (entry));
priv = entry->priv;
/* set a hint if we are blanking the entry */
if (priv->hint
&& text && !strcmp ("", text)
&& !HAS_FOCUS (priv->entry))
{
text = priv->hint;
priv->hint_visible = TRUE;
st_widget_add_style_pseudo_class (ST_WIDGET (entry), "indeterminate");
}
else
{
st_widget_remove_style_pseudo_class (ST_WIDGET (entry), "indeterminate");
priv->hint_visible = FALSE;
}
clutter_text_set_text (CLUTTER_TEXT (priv->entry), text);
g_object_notify (G_OBJECT (entry), "text");
}
static void
clutter_text_focus_in_cb (ClutterText *text,
ClutterActor *actor)
{
StEntry *entry = ST_ENTRY (actor);
StEntryPrivate *priv = entry->priv;
GdkKeymap *keymap;
/* remove the hint if visible */
if (priv->hint && priv->hint_visible)
{
priv->hint_visible = FALSE;
clutter_text_set_text (text, "");
}
keymap = gdk_keymap_get_for_display (gdk_display_get_default ());
keymap_state_changed (keymap, entry);
g_signal_connect (keymap, "state-changed",
G_CALLBACK (keymap_state_changed), entry);
st_widget_remove_style_pseudo_class (ST_WIDGET (actor), "indeterminate");
st_widget_add_style_pseudo_class (ST_WIDGET (actor), "focus");
clutter_text_set_cursor_visible (text, TRUE);
}
static gboolean
handle_button_press_event_cb (ClutterActor *actor,
ClutterButtonEvent *event,
StScrollBar *bar)
{
StScrollBarPrivate *priv = bar->priv;
if (event->button != 1)
return FALSE;
if (!clutter_actor_transform_stage_point (priv->handle,
event->x,
event->y,
&priv->x_origin,
&priv->y_origin))
return FALSE;
st_widget_add_style_pseudo_class (ST_WIDGET (priv->handle), "active");
/* Account for the scrollbar-trough-handle nesting. */
priv->x_origin += clutter_actor_get_x (priv->trough);
priv->y_origin += clutter_actor_get_y (priv->trough);
g_assert (!priv->grabbed);
clutter_grab_pointer (priv->handle);
priv->grabbed = TRUE;
g_signal_emit (bar, signals[SCROLL_START], 0);
return TRUE;
}
/**
* 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 #StWidget:has-tooltip is %TRUE, this
* will also show or hide the tooltip, as appropriate.
*
* 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 = widget->priv;
if (priv->hover != hover)
{
priv->hover = hover;
if (priv->hover)
{
st_widget_add_style_pseudo_class (widget, "hover");
if (priv->has_tooltip)
st_widget_show_tooltip (widget);
}
else
{
st_widget_remove_style_pseudo_class (widget, "hover");
if (priv->has_tooltip)
st_widget_hide_tooltip (widget);
}
g_object_notify (G_OBJECT (widget), "hover");
}
}
static void
st_button_press (StButton *button,
StButtonMask mask)
{
if (button->priv->pressed == 0)
st_widget_add_style_pseudo_class (ST_WIDGET (button), "active");
button->priv->pressed |= mask;
}
static void
st_button_press (StButton *button,
ClutterInputDevice *device,
StButtonMask mask,
ClutterEventSequence *sequence)
{
StButtonPrivate *priv = st_button_get_instance_private (button);
if (priv->pressed == 0 || sequence)
st_widget_add_style_pseudo_class (ST_WIDGET (button), "active");
priv->pressed |= mask;
priv->press_sequence = sequence;
priv->device = device;
}
/**
* st_button_set_checked:
* @button: a #Stbutton
* @checked: %TRUE or %FALSE
*
* Sets the pressed state of the button. This is only really useful if the
* button has #toggle-mode mode set to %TRUE.
*/
void
st_button_set_checked (StButton *button,
gboolean checked)
{
g_return_if_fail (ST_IS_BUTTON (button));
if (button->priv->is_checked != checked)
{
button->priv->is_checked = checked;
if (checked)
st_widget_add_style_pseudo_class (ST_WIDGET (button), "checked");
else
st_widget_remove_style_pseudo_class (ST_WIDGET (button), "checked");
}
g_object_notify (G_OBJECT (button), "checked");
}
/**
* st_entry_set_hint_text:
* @entry: a #StEntry
* @text: (allow-none): text to set as the entry hint
*
* Sets the text to display when the entry is empty and unfocused. When the
* entry is displaying the hint, it has a pseudo class of "indeterminate".
* A value of NULL unsets the hint.
*/
void
st_entry_set_hint_text (StEntry *entry,
const gchar *text)
{
StEntryPrivate *priv;
g_return_if_fail (ST_IS_ENTRY (entry));
priv = entry->priv;
g_free (priv->hint);
priv->hint = g_strdup (text);
if (!strcmp (clutter_text_get_text (CLUTTER_TEXT (priv->entry)), "")
&& !HAS_FOCUS (priv->entry))
{
priv->hint_visible = TRUE;
clutter_text_set_text (CLUTTER_TEXT (priv->entry), priv->hint);
st_widget_add_style_pseudo_class (ST_WIDGET (entry), "indeterminate");
}
}
static void
clutter_text_focus_out_cb (ClutterText *text,
ClutterActor *actor)
{
StEntry *entry = ST_ENTRY (actor);
StEntryPrivate *priv = entry->priv;
GdkKeymap *keymap;
st_widget_remove_style_pseudo_class (ST_WIDGET (actor), "focus");
/* add a hint if the entry is empty */
if (priv->hint && !strcmp (clutter_text_get_text (text), ""))
{
priv->hint_visible = TRUE;
clutter_text_set_text (text, priv->hint);
st_widget_add_style_pseudo_class (ST_WIDGET (actor), "indeterminate");
}
clutter_text_set_cursor_visible (text, FALSE);
remove_capslock_feedback (entry);
keymap = gdk_keymap_get_for_display (gdk_display_get_default ());
g_signal_handlers_disconnect_by_func (keymap, keymap_state_changed, entry);
}
