static void
st_scroll_bar_get_preferred_height (ClutterActor *self,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
StScrollBar *bar = ST_SCROLL_BAR (self);
StScrollBarPrivate *priv = bar->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
gfloat trough_min_height, trough_natural_height;
gfloat handle_min_height, handle_natural_height;
st_theme_node_adjust_for_width (theme_node, &for_width);
_st_actor_get_preferred_height (priv->trough, for_width, TRUE,
&trough_min_height, &trough_natural_height);
_st_actor_get_preferred_height (priv->handle, for_width, TRUE,
&handle_min_height, &handle_natural_height);
if (priv->vertical)
{
if (min_height_p)
*min_height_p = trough_min_height + handle_min_height;
if (natural_height_p)
*natural_height_p = trough_natural_height + handle_natural_height;
}
else
{
if (min_height_p)
*min_height_p = MAX (trough_min_height, handle_min_height);
if (natural_height_p)
*natural_height_p = MAX (trough_natural_height, handle_natural_height);
}
st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);
}
static gboolean
st_button_enter (ClutterActor *actor,
ClutterCrossingEvent *event)
{
StButton *button = ST_BUTTON (actor);
StButtonPrivate *priv = st_button_get_instance_private (button);
gboolean ret;
ret = CLUTTER_ACTOR_CLASS (st_button_parent_class)->enter_event (actor, event);
if (priv->grabbed)
{
if (st_widget_get_hover (ST_WIDGET (button)))
st_button_press (button, priv->device,
priv->grabbed, NULL);
else
st_button_release (button, priv->device,
priv->grabbed, 0, NULL);
}
return ret;
}
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));
/* Most subclasses will override this and not chain down. However,
* if they do not, then we need to override ClutterActor's default
* behavior (request 0x0) to take CSS-specified minimums into
* account (which st_theme_node_adjust_preferred_width() will do.)
*/
if (min_width_p)
*min_width_p = 0;
if (natural_width_p)
*natural_width_p = 0;
st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);
}
static gboolean
st_button_button_release (ClutterActor *actor,
ClutterButtonEvent *event)
{
StButton *button = ST_BUTTON (actor);
StButtonMask mask = ST_BUTTON_MASK_FROM_BUTTON (event->button);
if (button->priv->button_mask & mask)
{
gboolean is_click;
is_click = button->priv->grabbed && st_widget_get_hover (ST_WIDGET (button));
st_button_release (button, mask, is_click ? event->button : 0);
button->priv->grabbed &= ~mask;
if (button->priv->grabbed == 0)
clutter_ungrab_pointer ();
return TRUE;
}
return FALSE;
}
/**
* 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
st_table_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StTablePrivate *priv = ST_TABLE (self)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
ClutterActorBox content_box;
CLUTTER_ACTOR_CLASS (st_table_parent_class)->allocate (self, box, flags);
if (priv->n_cols < 1 || priv->n_rows < 1)
{
return;
};
st_theme_node_get_content_box (theme_node, box, &content_box);
if (priv->homogeneous)
st_table_homogeneous_allocate (self, &content_box, flags);
else
st_table_preferred_allocate (self, &content_box, flags);
}
static void
st_button_style_changed (StWidget *widget)
{
StButton *button = ST_BUTTON (widget);
StButtonPrivate *priv = button->priv;
StButtonClass *button_class = ST_BUTTON_GET_CLASS (button);
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (button));
double spacing;
ST_WIDGET_CLASS (st_button_parent_class)->style_changed (widget);
spacing = 6;
st_theme_node_lookup_length (theme_node, "border-spacing", FALSE, &spacing);
priv->spacing = (int)(0.5 + spacing);
/* update the label styling */
st_button_update_label_style (button);
/* run a transition if applicable */
if (button_class->transition)
{
button_class->transition (button);
}
}
static void
st_bin_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StBinPrivate *priv = ST_BIN (self)->priv;
clutter_actor_set_allocation (self, box, flags);
if (priv->child && clutter_actor_is_visible (priv->child))
{
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
ClutterActorBox childbox;
gdouble x_align_f, y_align_f;
st_theme_node_get_content_box (theme_node, box, &childbox);
_st_get_align_factors (priv->x_align, priv->y_align,
&x_align_f, &y_align_f);
clutter_actor_allocate_align_fill (priv->child, &childbox,
x_align_f, y_align_f,
priv->x_fill, priv->y_fill,
flags);
}
}
static void
st_entry_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
ClutterActorClass *parent_class;
ClutterActorBox content_box, child_box, icon_box;
gfloat icon_w, icon_h;
gfloat entry_h, min_h, pref_h, avail_h;
parent_class = CLUTTER_ACTOR_CLASS (st_entry_parent_class);
parent_class->allocate (actor, box, flags);
st_theme_node_get_content_box (theme_node, box, &content_box);
avail_h = content_box.y2 - content_box.y1;
child_box.x1 = content_box.x1;
child_box.x2 = content_box.x2;
if (priv->primary_icon)
{
clutter_actor_get_preferred_width (priv->primary_icon,
-1, NULL, &icon_w);
clutter_actor_get_preferred_height (priv->primary_icon,
-1, NULL, &icon_h);
icon_box.x1 = content_box.x1;
icon_box.x2 = icon_box.x1 + icon_w;
icon_box.y1 = (int) (content_box.y1 + avail_h / 2 - icon_h / 2);
icon_box.y2 = icon_box.y1 + icon_h;
clutter_actor_allocate (priv->primary_icon,
&icon_box,
flags);
/* reduce the size for the entry */
child_box.x1 += icon_w + priv->spacing;
}
if (priv->secondary_icon)
{
clutter_actor_get_preferred_width (priv->secondary_icon,
-1, NULL, &icon_w);
clutter_actor_get_preferred_height (priv->secondary_icon,
-1, NULL, &icon_h);
icon_box.x2 = content_box.x2;
icon_box.x1 = icon_box.x2 - icon_w;
icon_box.y1 = (int) (content_box.y1 + avail_h / 2 - icon_h / 2);
icon_box.y2 = icon_box.y1 + icon_h;
clutter_actor_allocate (priv->secondary_icon,
&icon_box,
flags);
/* reduce the size for the entry */
child_box.x2 -= icon_w - priv->spacing;
}
clutter_actor_get_preferred_height (priv->entry, child_box.x2 - child_box.x1,
&min_h, &pref_h);
entry_h = CLAMP (pref_h, min_h, avail_h);
child_box.y1 = (int) (content_box.y1 + avail_h / 2 - entry_h / 2);
child_box.y2 = child_box.y1 + entry_h;
clutter_actor_allocate (priv->entry, &child_box, flags);
}
static void
st_scroll_view_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
ClutterActorBox content_box, child_box;
ClutterActorClass *parent_parent_class;
gfloat avail_width, avail_height, sb_width, sb_height;
gboolean hscrollbar_visible, vscrollbar_visible;
StScrollViewPrivate *priv = ST_SCROLL_VIEW (actor)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
/* Chain up to the parent's parent class
*
* We do this because we do not want StBin to allocate the child, as we
* give it a different allocation later, depending on whether the scrollbars
* are visible
*/
parent_parent_class
= g_type_class_peek_parent (st_scroll_view_parent_class);
CLUTTER_ACTOR_CLASS (parent_parent_class)->
allocate (actor, box, flags);
st_theme_node_get_content_box (theme_node, box, &content_box);
avail_width = content_box.x2 - content_box.x1;
avail_height = content_box.y2 - content_box.y1;
if (clutter_actor_get_request_mode (actor) == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
{
sb_width = get_scrollbar_width (ST_SCROLL_VIEW (actor), -1);
sb_height = get_scrollbar_height (ST_SCROLL_VIEW (actor), sb_width);
}
else
{
sb_height = get_scrollbar_height (ST_SCROLL_VIEW (actor), -1);
sb_width = get_scrollbar_width (ST_SCROLL_VIEW (actor), sb_height);
}
/* Determine what scrollbars are visible. The basic idea of the
* handling of an automatic scrollbars is that we start off with the
* assumption that we don't need any scrollbars, see if that works,
* and if not add horizontal and vertical scrollbars until we are no
* longer overflowing.
*/
if (priv->child)
{
gfloat child_min_width;
gfloat child_min_height;
clutter_actor_get_preferred_width (priv->child, -1,
&child_min_width, NULL);
if (priv->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
{
if (priv->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
{
/* Pass one, try without a vertical scrollbar */
clutter_actor_get_preferred_height (priv->child, avail_width, &child_min_height, NULL);
vscrollbar_visible = child_min_height > avail_height;
hscrollbar_visible = child_min_width > avail_width - (vscrollbar_visible ? sb_width : 0);
vscrollbar_visible = child_min_height > avail_height - (hscrollbar_visible ? sb_height : 0);
/* Pass two - if we needed a vertical scrollbar, get a new preferred height */
if (vscrollbar_visible)
{
clutter_actor_get_preferred_height (priv->child, MAX (avail_width - sb_width, 0),
&child_min_height, NULL);
hscrollbar_visible = child_min_width > avail_width - sb_width;
}
}
else
{
hscrollbar_visible = priv->hscrollbar_policy != GTK_POLICY_NEVER;
/* try without a vertical scrollbar */
clutter_actor_get_preferred_height (priv->child, avail_width, &child_min_height, NULL);
vscrollbar_visible = child_min_height > avail_height - (hscrollbar_visible ? sb_height : 0);
}
}
else
{
vscrollbar_visible = priv->vscrollbar_policy != GTK_POLICY_NEVER;
if (priv->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
hscrollbar_visible = child_min_width > avail_height - (vscrollbar_visible ? 0 : sb_width);
else
hscrollbar_visible = priv->hscrollbar_policy != GTK_POLICY_NEVER;
}
}
else
{
hscrollbar_visible = priv->hscrollbar_policy != GTK_POLICY_NEVER;
vscrollbar_visible = priv->vscrollbar_policy != GTK_POLICY_NEVER;
}
/* Whether or not we show the scrollbars, if the scrollbars are visible
* actors, we need to give them some allocation, so we unconditionally
* give them the "right" allocation; that might overlap the child when
* the scrollbars are not visible, but it doesn't matter because we
* don't include them in pick or paint.
*/
/* Vertical scrollbar */
if (CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
{
if (st_widget_get_direction (ST_WIDGET (actor)) == ST_TEXT_DIRECTION_RTL)
{
child_box.x1 = content_box.x1;
child_box.x2 = content_box.x1 + sb_width;
}
else
{
child_box.x1 = content_box.x2 - sb_width;
child_box.x2 = content_box.x2;
}
child_box.y1 = content_box.y1;
child_box.y2 = content_box.y2 - (hscrollbar_visible ? sb_height : 0);
clutter_actor_allocate (priv->vscroll, &child_box, flags);
}
/* Horizontal scrollbar */
if (CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
{
if (st_widget_get_direction (ST_WIDGET (actor)) == ST_TEXT_DIRECTION_RTL)
{
child_box.x1 = content_box.x1 + (vscrollbar_visible ? sb_width : 0);
child_box.x2 = content_box.x2;
}
else
{
child_box.x1 = content_box.x1;
child_box.x2 = content_box.x2 - (vscrollbar_visible ? sb_width : 0);
}
child_box.y1 = content_box.y2 - sb_height;
child_box.y2 = content_box.y2;
clutter_actor_allocate (priv->hscroll, &child_box, flags);
}
/* Now fold visibility into the scrollbar sizes to simplify the rest
* of the computations.
*/
if (!hscrollbar_visible)
sb_height = 0;
if (!vscrollbar_visible)
sb_width = 0;
/* Child */
if (st_widget_get_direction (ST_WIDGET (actor)) == ST_TEXT_DIRECTION_RTL)
{
child_box.x1 = content_box.x1 + sb_width;
child_box.x2 = content_box.x2;
}
else
{
child_box.x1 = content_box.x1;
child_box.x2 = content_box.x2 - sb_width;
}
child_box.y1 = content_box.y1;
child_box.y2 = content_box.y2 - sb_height;
if (priv->child)
clutter_actor_allocate (priv->child, &child_box, flags);
if (priv->hscrollbar_visible != hscrollbar_visible)
{
g_object_freeze_notify (G_OBJECT (actor));
priv->hscrollbar_visible = hscrollbar_visible;
g_object_notify (G_OBJECT (actor), "hscrollbar-visible");
g_object_thaw_notify (G_OBJECT (actor));
}
if (priv->vscrollbar_visible != vscrollbar_visible)
{
g_object_freeze_notify (G_OBJECT (actor));
priv->vscrollbar_visible = vscrollbar_visible;
g_object_notify (G_OBJECT (actor), "vscrollbar-visible");
g_object_thaw_notify (G_OBJECT (actor));
}
}
static void
st_scroll_view_get_preferred_height (ClutterActor *actor,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
StScrollViewPrivate *priv = ST_SCROLL_VIEW (actor)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
gboolean account_for_hscrollbar = FALSE;
gfloat min_height = 0, natural_height;
gfloat child_min_height, child_natural_height;
gfloat child_min_width;
gfloat sb_width;
if (!priv->child)
return;
st_theme_node_adjust_for_width (theme_node, &for_width);
clutter_actor_get_preferred_width (priv->child, -1,
&child_min_width, NULL);
if (min_height_p)
*min_height_p = 0;
sb_width = get_scrollbar_width (ST_SCROLL_VIEW (actor), -1);
switch (priv->vscrollbar_policy)
{
case GTK_POLICY_NEVER:
break;
case GTK_POLICY_ALWAYS:
case GTK_POLICY_AUTOMATIC:
/* We've requested space for the scrollbar, subtract it back out */
for_width -= sb_width;
break;
}
switch (priv->hscrollbar_policy)
{
case GTK_POLICY_NEVER:
account_for_hscrollbar = FALSE;
break;
case GTK_POLICY_ALWAYS:
account_for_hscrollbar = TRUE;
break;
case GTK_POLICY_AUTOMATIC:
account_for_hscrollbar = for_width < child_min_width;
break;
}
clutter_actor_get_preferred_height (priv->child, for_width,
&child_min_height, &child_natural_height);
natural_height = child_natural_height;
switch (priv->vscrollbar_policy)
{
case GTK_POLICY_NEVER:
min_height = child_min_height;
break;
case GTK_POLICY_ALWAYS:
case GTK_POLICY_AUTOMATIC:
/* Should theoretically use the min height of the vscrollbar,
* but that's not cleanly defined at the moment */
min_height = 0;
break;
}
if (account_for_hscrollbar)
{
float sb_height = get_scrollbar_height (ST_SCROLL_VIEW (actor), for_width);
min_height += sb_height;
natural_height += sb_height;
}
if (min_height_p)
*min_height_p = min_height;
if (natural_height_p)
*natural_height_p = natural_height;
st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);
}
static void
st_scroll_view_fade_paint_target (ClutterOffscreenEffect *effect)
{
StScrollViewFade *self = ST_SCROLL_VIEW_FADE (effect);
ClutterOffscreenEffectClass *parent;
CoglHandle material;
gdouble value, lower, upper, page_size;
ClutterActor *vscroll = st_scroll_view_get_vscroll_bar (ST_SCROLL_VIEW (self->actor));
ClutterActor *hscroll = st_scroll_view_get_hscroll_bar (ST_SCROLL_VIEW (self->actor));
gboolean h_scroll_visible, v_scroll_visible;
ClutterActorBox allocation, content_box, paint_box;
/*
* Used to pass the fade area to the shader
*
* [0][0] = x1
* [0][1] = y1
* [1][0] = x2
* [1][1] = y2
*
*/
float fade_area[2][2];
ClutterVertex verts[4];
if (self->program == COGL_INVALID_HANDLE)
goto out;
clutter_actor_get_paint_box (self->actor, &paint_box);
clutter_actor_get_abs_allocation_vertices (self->actor, verts);
clutter_actor_get_allocation_box (self->actor, &allocation);
st_theme_node_get_content_box (st_widget_get_theme_node (ST_WIDGET (self->actor)),
(const ClutterActorBox *)&allocation, &content_box);
/*
* The FBO is based on the paint_volume's size which can be larger then the actual
* allocation, so we have to account for that when passing the positions
*/
fade_area[0][0] = content_box.x1 + (verts[0].x - paint_box.x1);
fade_area[0][1] = content_box.y1 + (verts[0].y - paint_box.y1);
fade_area[1][0] = content_box.x2 + (verts[3].x - paint_box.x2);
fade_area[1][1] = content_box.y2 + (verts[3].y - paint_box.y2);
g_object_get (ST_SCROLL_VIEW (self->actor),
"hscrollbar-visible", &h_scroll_visible,
"vscrollbar-visible", &v_scroll_visible,
NULL);
if (v_scroll_visible)
{
if (st_widget_get_direction (ST_WIDGET (self->actor)) == ST_TEXT_DIRECTION_RTL)
fade_area[0][0] += clutter_actor_get_width (vscroll);
fade_area[1][0] -= clutter_actor_get_width (vscroll);
}
if (h_scroll_visible)
fade_area[1][1] -= clutter_actor_get_height (hscroll);
st_adjustment_get_values (self->vadjustment, &value, &lower, &upper, NULL, NULL, &page_size);
if (self->offset_top_uniform > -1) {
if (value > lower + 0.1)
cogl_program_set_uniform_1f (self->program, self->offset_top_uniform, self->fade_offset);
else
cogl_program_set_uniform_1f (self->program, self->offset_top_uniform, 0.0f);
}
if (self->offset_bottom_uniform > -1) {
if (value < upper - page_size - 0.1)
cogl_program_set_uniform_1f (self->program, self->offset_bottom_uniform, self->fade_offset);
else
cogl_program_set_uniform_1f (self->program, self->offset_bottom_uniform, 0.0f);
}
if (self->tex_uniform > -1)
cogl_program_set_uniform_1i (self->program, self->tex_uniform, 0);
if (self->height_uniform > -1)
cogl_program_set_uniform_1f (self->program, self->height_uniform, clutter_actor_get_height (self->actor));
if (self->width_uniform > -1)
cogl_program_set_uniform_1f (self->program, self->width_uniform, clutter_actor_get_width (self->actor));
if (self->fade_area_uniform > -1)
cogl_program_set_uniform_matrix (self->program, self->fade_area_uniform, 2, 1, FALSE, (const float *)fade_area);
material = clutter_offscreen_effect_get_target (effect);
cogl_material_set_user_program (material, self->program);
out:
parent = CLUTTER_OFFSCREEN_EFFECT_CLASS (st_scroll_view_fade_parent_class);
parent->paint_target (effect);
}
static void
st_table_homogeneous_allocate (ClutterActor *self,
const ClutterActorBox *content_box,
gboolean flags)
{
GList *list, *children;
gfloat col_width, row_height;
gint row_spacing, col_spacing;
StTablePrivate *priv = ST_TABLE (self)->priv;
gboolean ltr = st_widget_get_direction (ST_WIDGET (self)) == ST_TEXT_DIRECTION_LTR;
col_spacing = priv->col_spacing;
row_spacing = priv->row_spacing;
col_width = (int) ((content_box->x2 - content_box->x1
- (col_spacing * (priv->n_cols - 1)))
/ priv->n_cols + 0.5);
row_height = (int) ((content_box->y2 - content_box->y1
- (row_spacing * (priv->n_rows - 1)))
/ priv->n_rows + 0.5);
children = st_container_get_children_list (ST_CONTAINER (self));
for (list = children; list; list = list->next)
{
gint row, col, row_span, col_span;
StTableChild *meta;
ClutterActor *child;
ClutterActorBox childbox;
StAlign x_align, y_align;
gboolean x_fill, y_fill;
child = CLUTTER_ACTOR (list->data);
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
row_span = meta->row_span;
col_span = meta->col_span;
x_align = meta->x_align;
y_align = meta->y_align;
x_fill = meta->x_fill;
y_fill = meta->y_fill;
if (ltr)
{
childbox.x1 = content_box->x1 + (col_width + col_spacing) * col;
childbox.x2 = childbox.x1 + (col_width * col_span) + (col_spacing * (col_span - 1));
}
else
{
childbox.x2 = content_box->x2 - (col_width + col_spacing) * col;
childbox.x1 = childbox.x2 - (col_width * col_span) - (col_spacing * (col_span - 1));
}
childbox.y1 = content_box->y1 + (row_height + row_spacing) * row;
childbox.y2 = childbox.y1 + (row_height * row_span) + (row_spacing * (row_span - 1));
_st_allocate_fill (ST_WIDGET (self), child, &childbox,
x_align, y_align, x_fill, y_fill);
clutter_actor_allocate (child, &childbox, flags);
}
}
static void
scroll_bar_allocate_children (StScrollBar *bar,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StScrollBarPrivate *priv = bar->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (bar));
ClutterActorBox content_box, trough_box;
st_theme_node_get_content_box (theme_node, box, &content_box);
if (priv->vertical)
{
trough_box.x1 = content_box.x1;
trough_box.y1 = content_box.y1;
trough_box.x2 = content_box.x2;
trough_box.y2 = content_box.y2;
clutter_actor_allocate (priv->trough, &trough_box, flags);
}
else
{
trough_box.x1 = content_box.x1;
trough_box.y1 = content_box.y1;
trough_box.x2 = content_box.x2;
trough_box.y2 = content_box.y2;
clutter_actor_allocate (priv->trough, &trough_box, flags);
}
if (priv->adjustment)
{
float handle_size, position, avail_size;
gdouble value, lower, upper, page_size, increment, min_size, max_size;
ClutterActorBox handle_box = { 0, };
st_adjustment_get_values (priv->adjustment,
&value,
&lower,
&upper,
NULL,
NULL,
&page_size);
if ((upper == lower)
|| (page_size >= (upper - lower)))
increment = 1.0;
else
increment = page_size / (upper - lower);
min_size = 32.;
st_theme_node_lookup_length (theme_node, "min-size", FALSE, &min_size);
max_size = G_MAXINT16;
st_theme_node_lookup_length (theme_node, "max-size", FALSE, &max_size);
if (upper - lower - page_size <= 0)
position = 0;
else
position = (value - lower) / (upper - lower - page_size);
if (priv->vertical)
{
avail_size = content_box.y2 - content_box.y1;
handle_size = increment * avail_size;
handle_size = CLAMP (handle_size, min_size, max_size);
handle_box.x1 = content_box.x1;
handle_box.y1 = content_box.y1 + position * (avail_size - handle_size);
handle_box.x2 = content_box.x2;
handle_box.y2 = handle_box.y1 + handle_size;
}
else
{
avail_size = content_box.x2 - content_box.x1;
handle_size = increment * avail_size;
handle_size = CLAMP (handle_size, min_size, max_size);
handle_box.x1 = content_box.x1 + position * (avail_size - handle_size);
handle_box.y1 = content_box.y1;
handle_box.x2 = handle_box.x1 + handle_size;
handle_box.y2 = content_box.y2;
}
clutter_actor_allocate (priv->handle,
&handle_box,
flags);
}
}
static void
st_drawing_area_paint (ClutterActor *self)
{
StDrawingArea *area = ST_DRAWING_AREA (self);
StDrawingAreaPrivate *priv = area->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
ClutterActorBox allocation_box;
ClutterActorBox content_box;
int width, height;
CoglColor color;
guint8 paint_opacity;
(CLUTTER_ACTOR_CLASS (st_drawing_area_parent_class))->paint (self);
clutter_actor_get_allocation_box (self, &allocation_box);
st_theme_node_get_content_box (theme_node, &allocation_box, &content_box);
width = (int)(0.5 + content_box.x2 - content_box.x1);
height = (int)(0.5 + content_box.y2 - content_box.y1);
if (priv->material == COGL_INVALID_HANDLE)
priv->material = cogl_material_new ();
if (priv->texture != COGL_INVALID_HANDLE &&
(width != cogl_texture_get_width (priv->texture) ||
height != cogl_texture_get_height (priv->texture)))
{
cogl_handle_unref (priv->texture);
priv->texture = COGL_INVALID_HANDLE;
}
if (width > 0 && height > 0)
{
if (priv->texture == COGL_INVALID_HANDLE)
{
priv->texture = cogl_texture_new_with_size (width, height,
COGL_TEXTURE_NONE,
CLUTTER_CAIRO_FORMAT_ARGB32);
priv->needs_repaint = TRUE;
}
if (priv->needs_repaint)
{
cairo_surface_t *surface;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
priv->context = cairo_create (surface);
priv->in_repaint = TRUE;
priv->needs_repaint = FALSE;
g_signal_emit ((GObject*)area, st_drawing_area_signals[REPAINT], 0);
priv->in_repaint = FALSE;
cairo_destroy (priv->context);
priv->context = NULL;
cogl_texture_set_region (priv->texture, 0, 0, 0, 0, width, height, width, height,
CLUTTER_CAIRO_FORMAT_ARGB32,
cairo_image_surface_get_stride (surface),
cairo_image_surface_get_data (surface));
cairo_surface_destroy (surface);
}
}
cogl_material_set_layer (priv->material, 0, priv->texture);
if (priv->texture)
{
paint_opacity = clutter_actor_get_paint_opacity (self);
cogl_color_set_from_4ub (&color,
paint_opacity, paint_opacity, paint_opacity, paint_opacity);
cogl_material_set_color (priv->material, &color);
cogl_set_source (priv->material);
cogl_rectangle_with_texture_coords (content_box.x1, content_box.y1,
width, height,
0.0f, 0.0f, 1.0f, 1.0f);
}
}
static void
st_icon_update (StIcon *icon)
{
StIconPrivate *priv = icon->priv;
StThemeNode *theme_node;
StTextureCache *cache;
gint scale;
ClutterActor *stage;
StThemeContext *context;
if (priv->pending_texture)
{
clutter_actor_destroy (priv->pending_texture);
g_object_unref (priv->pending_texture);
priv->pending_texture = NULL;
priv->opacity_handler_id = 0;
}
theme_node = st_widget_peek_theme_node (ST_WIDGET (icon));
if (theme_node == NULL)
return;
stage = clutter_actor_get_stage (CLUTTER_ACTOR (icon));
context = st_theme_context_get_for_stage (CLUTTER_STAGE (stage));
g_object_get (context, "scale-factor", &scale, NULL);
priv->icon_scale = scale;
cache = st_texture_cache_get_default ();
if (priv->gicon)
{
priv->pending_texture = st_texture_cache_load_gicon (cache,
(priv->icon_type != ST_ICON_APPLICATION &&
priv->icon_type != ST_ICON_DOCUMENT) ?
theme_node : NULL,
priv->gicon,
priv->icon_size);
}
else if (priv->icon_name)
{
priv->pending_texture = st_texture_cache_load_icon_name (cache,
theme_node,
priv->icon_name,
priv->icon_type,
priv->icon_size);
}
if (priv->pending_texture)
{
g_object_ref_sink (priv->pending_texture);
if (clutter_actor_get_opacity (priv->pending_texture) != 0 || priv->icon_texture == NULL)
{
/* This icon is ready for showing, or nothing else is already showing */
st_icon_finish_update (icon);
}
else
{
/* Will be shown when fully loaded */
priv->opacity_handler_id = g_signal_connect (priv->pending_texture, "notify::opacity", G_CALLBACK (opacity_changed_cb), icon);
}
}
else if (priv->icon_texture)
{
clutter_actor_destroy (priv->icon_texture);
priv->icon_texture = NULL;
}
}
static void
st_box_layout_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StBoxLayoutPrivate *priv = ST_BOX_LAYOUT (actor)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
ClutterActorBox content_box;
gfloat avail_width, avail_height, min_width, natural_width, min_height, natural_height;
gfloat position, next_position;
GList *l, *children;
gint n_expand_children = 0, i;
gfloat expand_amount, shrink_amount;
BoxChildShrink *shrinks = NULL;
gboolean flip = (st_widget_get_direction (ST_WIDGET (actor)) == ST_TEXT_DIRECTION_RTL)
&& (!priv->is_vertical);
CLUTTER_ACTOR_CLASS (st_box_layout_parent_class)->allocate (actor, box,
flags);
children = st_container_get_children_list (ST_CONTAINER (actor));
if (children == NULL)
return;
st_theme_node_get_content_box (theme_node, box, &content_box);
avail_width = content_box.x2 - content_box.x1;
avail_height = content_box.y2 - content_box.y1;
get_content_preferred_width (ST_BOX_LAYOUT (actor), avail_height,
&min_width, &natural_width);
get_content_preferred_height (ST_BOX_LAYOUT (actor), MAX (avail_width, min_width),
&min_height, &natural_height);
/* update adjustments for scrolling */
if (priv->vadjustment)
{
gdouble prev_value;
g_object_set (G_OBJECT (priv->vadjustment),
"lower", 0.0,
"upper", MAX (min_height, avail_height),
"page-size", avail_height,
"step-increment", avail_height / 6,
"page-increment", avail_height - avail_height / 6,
NULL);
prev_value = st_adjustment_get_value (priv->vadjustment);
st_adjustment_set_value (priv->vadjustment, prev_value);
}
if (priv->hadjustment)
{
gdouble prev_value;
g_object_set (G_OBJECT (priv->hadjustment),
"lower", 0.0,
"upper", MAX (min_width, avail_width),
"page-size", avail_width,
"step-increment", avail_width / 6,
"page-increment", avail_width - avail_width / 6,
NULL);
prev_value = st_adjustment_get_value (priv->hadjustment);
st_adjustment_set_value (priv->hadjustment, prev_value);
}
if (avail_height < min_height)
{
avail_height = min_height;
content_box.y2 = content_box.y1 + avail_height;
}
if (avail_width < min_width)
{
avail_width = min_width;
content_box.x2 = content_box.x1 + avail_width;
}
if (priv->is_vertical)
{
expand_amount = MAX (0, avail_height - natural_height);
shrink_amount = MAX (0, natural_height - avail_height);
}
else
{
expand_amount = MAX (0, avail_width - natural_width);
shrink_amount = MAX (0, natural_width - avail_width);
}
if (expand_amount > 0)
{
/* count the number of children with expand set to TRUE */
n_expand_children = 0;
for (l = children; l; l = l->next)
{
ClutterActor *child = l->data;
gboolean expand;
if (!CLUTTER_ACTOR_IS_VISIBLE (child) ||
clutter_actor_get_fixed_position_set (child))
continue;
clutter_container_child_get ((ClutterContainer *) actor,
child,
"expand", &expand,
NULL);
if (expand)
n_expand_children++;
}
if (n_expand_children == 0)
expand_amount = 0;
}
else if (shrink_amount > 0)
{
shrinks = compute_shrinks (ST_BOX_LAYOUT (actor),
priv->is_vertical ? avail_width : avail_height,
shrink_amount);
}
if (priv->is_vertical)
position = content_box.y1;
else if (flip)
position = content_box.x2;
else
position = content_box.x1;
if (priv->is_pack_start)
{
l = g_list_last (children);
i = g_list_length (children);
}
else
{
l = children;
i = 0;
}
gboolean firstchild = TRUE;
gfloat init_padding = (avail_width/2) - (natural_width/2);
while (l)
{
ClutterActor *child = (ClutterActor*) l->data;
ClutterActorBox child_box;
gfloat child_min, child_nat, child_allocated;
gboolean xfill, yfill, expand, fixed;
StAlign xalign, yalign;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
goto next_child;
fixed = clutter_actor_get_fixed_position_set (child);
if (fixed)
{
clutter_actor_allocate_preferred_size (child, flags);
goto next_child;
}
clutter_container_child_get ((ClutterContainer*) actor, child,
"x-fill", &xfill,
"y-fill", &yfill,
"x-align", &xalign,
"y-align", &yalign,
"expand", &expand,
NULL);
if (priv->is_vertical)
{
_st_actor_get_preferred_height (child, avail_width, xfill,
&child_min, &child_nat);
}
else
{
_st_actor_get_preferred_width (child, avail_height, yfill,
&child_min, &child_nat);
}
child_allocated = child_nat;
if (expand_amount > 0 && expand)
child_allocated += expand_amount / n_expand_children;
else if (shrink_amount > 0)
child_allocated -= shrinks[i].shrink_amount;
if (flip) {
next_position = position - child_allocated;
if (xalign == ST_ALIGN_CENTER_SPECIAL && next_position < content_box.x1)
next_position = content_box.x1;
}
else {
next_position = position + child_allocated;
if (xalign == ST_ALIGN_CENTER_SPECIAL && next_position > content_box.x2)
next_position = content_box.x2;
}
if (priv->is_vertical)
{
child_box.y1 = (int)(0.5 + position);
child_box.y2 = (int)(0.5 + next_position);
child_box.x1 = content_box.x1;
child_box.x2 = content_box.x2;
_st_allocate_fill (ST_WIDGET (actor), child, &child_box,
xalign, yalign, xfill, yfill);
clutter_actor_allocate (child, &child_box, flags);
}
else
{
if (flip)
{
if (firstchild && xalign == ST_ALIGN_CENTER_SPECIAL)
{
position -= init_padding;
next_position = position - child_allocated;
firstchild = FALSE;
}
if (xalign == ST_ALIGN_CENTER_SPECIAL && position > content_box.x2) {
position = content_box.x2;
}
child_box.x1 = (int)(0.5 + next_position);
child_box.x2 = (int)(0.5 + position);
}
else
{
if (firstchild && xalign == ST_ALIGN_CENTER_SPECIAL)
{
position += init_padding;
if (position < content_box.x1) {
position = content_box.x1;
}
next_position = position + child_allocated;
firstchild = FALSE;
}
if (xalign == ST_ALIGN_CENTER_SPECIAL && position < content_box.x1) {
position = content_box.x1;
}
child_box.x1 = (int)(0.5 + position);
child_box.x2 = (int)(0.5 + next_position);
}
child_box.y1 = content_box.y1;
child_box.y2 = content_box.y2;
_st_allocate_fill (ST_WIDGET (actor), child, &child_box,
xalign, yalign, xfill, yfill);
clutter_actor_allocate (child, &child_box, flags);
}
if (flip)
position = next_position - priv->spacing;
else
position = next_position + priv->spacing;
next_child:
if (priv->is_pack_start)
{
l = l->prev;
i--;
}
else
{
l = l->next;
i++;
}
}
if (shrinks)
g_free (shrinks);
}
static void
st_scroll_view_fade_paint_target (ClutterOffscreenEffect *effect)
{
StScrollViewFade *self = ST_SCROLL_VIEW_FADE (effect);
ClutterOffscreenEffectClass *parent;
CoglHandle material;
gdouble value, lower, upper, page_size;
ClutterActor *vscroll = st_scroll_view_get_vscroll_bar (ST_SCROLL_VIEW (self->actor));
ClutterActor *hscroll = st_scroll_view_get_hscroll_bar (ST_SCROLL_VIEW (self->actor));
gboolean h_scroll_visible, v_scroll_visible;
g_object_get (ST_SCROLL_VIEW (self->actor),
"hscrollbar-visible", &h_scroll_visible,
"vscrollbar-visible", &v_scroll_visible,
NULL);
if (self->program == COGL_INVALID_HANDLE)
goto out;
st_adjustment_get_values (self->vadjustment, &value, &lower, &upper, NULL, NULL, &page_size);
if (self->offset_top_uniform > -1) {
if (value > lower + 0.1)
cogl_program_set_uniform_1f (self->program, self->offset_top_uniform, self->fade_offset);
else
cogl_program_set_uniform_1f (self->program, self->offset_top_uniform, 0.0f);
}
if (self->offset_bottom_uniform > -1) {
if (value < upper - page_size - 0.1)
cogl_program_set_uniform_1f (self->program, self->offset_bottom_uniform, self->fade_offset);
else
cogl_program_set_uniform_1f (self->program, self->offset_bottom_uniform, 0.0f);
}
if (self->tex_uniform > -1)
cogl_program_set_uniform_1i (self->program, self->tex_uniform, 0);
if (self->height_uniform > -1)
cogl_program_set_uniform_1f (self->program, self->height_uniform, clutter_actor_get_height (self->actor));
if (self->width_uniform > -1)
cogl_program_set_uniform_1f (self->program, self->width_uniform, clutter_actor_get_width (self->actor));
if (self->scrollbar_width_uniform > -1)
cogl_program_set_uniform_1f (self->program, self->scrollbar_width_uniform, v_scroll_visible ? clutter_actor_get_width (vscroll) : 0);
if (self->scrollbar_height_uniform > -1)
cogl_program_set_uniform_1f (self->program, self->scrollbar_height_uniform, h_scroll_visible ? clutter_actor_get_height (hscroll) : 0);
if (self->rtl_uniform > -1)
cogl_program_set_uniform_1i (self->program, self->rtl_uniform, (st_widget_get_direction (ST_WIDGET (self->actor)) == ST_TEXT_DIRECTION_RTL));
material = clutter_offscreen_effect_get_target (effect);
cogl_material_set_user_program (material, self->program);
out:
parent = CLUTTER_OFFSCREEN_EFFECT_CLASS (st_scroll_view_fade_parent_class);
parent->paint_target (effect);
}
static gboolean
st_container_navigate_focus (StWidget *widget,
ClutterActor *from,
GtkDirectionType direction)
{
StContainer *container = ST_CONTAINER (widget);
ClutterActor *container_actor, *focus_child;
GList *children, *l;
container_actor = CLUTTER_ACTOR (widget);
if (from == container_actor)
return FALSE;
/* Figure out if @from is a descendant of @container, and if so,
* set @focus_child to the immediate child of @container that
* contains (or *is*) @from.
*/
focus_child = from;
while (focus_child && clutter_actor_get_parent (focus_child) != container_actor)
focus_child = clutter_actor_get_parent (focus_child);
if (st_widget_get_can_focus (widget))
{
if (!focus_child)
{
/* Accept focus from outside */
clutter_actor_grab_key_focus (container_actor);
return TRUE;
}
else
{
/* Yield focus from within: since @container itself is
* focusable we don't allow the focus to be navigated
* within @container.
*/
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;
}
/* At this point we know that we want to navigate focus to one of
* @container'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.)
*/
children = st_container_get_focus_chain (container);
if (direction == GTK_DIR_TAB_FORWARD ||
direction == GTK_DIR_TAB_BACKWARD)
{
if (direction == GTK_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 */
{
StContainerChildSortData sort_data;
/* Compute the allocation box of the previous focused actor, in
* @container's coordinate space. If there was no previous focus,
* use the coordinates of the appropriate edge of @container.
*
* Note that all of this code assumes the actors are not
* transformed (or at most, they are all scaled by the same
* amount). If @container or any of its children is rotated, or
* any child is inconsistently scaled, then the focus chain will
* probably be unpredictable.
*/
if (focus_child)
{
clutter_actor_get_allocation_box (focus_child, &sort_data.box);
}
else
{
clutter_actor_get_allocation_box (CLUTTER_ACTOR (container), &sort_data.box);
switch (direction)
{
case GTK_DIR_UP:
sort_data.box.y1 = sort_data.box.y2;
break;
case GTK_DIR_DOWN:
sort_data.box.y2 = sort_data.box.y1;
break;
case GTK_DIR_LEFT:
sort_data.box.x1 = sort_data.box.x2;
break;
case GTK_DIR_RIGHT:
sort_data.box.x2 = sort_data.box.x1;
break;
default:
g_warn_if_reached ();
}
}
sort_data.direction = direction;
if (focus_child)
children = filter_by_position (children, &sort_data.box, direction);
if (children)
children = g_list_sort_with_data (children, sort_by_position, &sort_data);
}
/* 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;
}
static void
st_table_get_preferred_width (ClutterActor *self,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
gint *min_widths, *pref_widths;
gfloat total_min_width, total_pref_width;
StTablePrivate *priv = ST_TABLE (self)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
gint i;
ClutterActor *child;
if (priv->n_cols < 1)
{
*min_width_p = 0;
*natural_width_p = 0;
return;
}
/* Setting size to zero and then what we want it to be causes a clear if
* clear flag is set (which it should be.)
*/
g_array_set_size (priv->min_widths, 0);
g_array_set_size (priv->pref_widths, 0);
g_array_set_size (priv->min_widths, priv->n_cols);
g_array_set_size (priv->pref_widths, priv->n_cols);
min_widths = (gint *) priv->min_widths->data;
pref_widths = (gint *) priv->pref_widths->data;
/* calculate minimum row widths */
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint col, col_span;
gfloat w_min, w_pref;
StTableChild *meta;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
col_span = meta->col_span;
_st_actor_get_preferred_width (child, -1, meta->y_fill, &w_min, &w_pref);
if (col_span == 1 && w_min > min_widths[col])
min_widths[col] = w_min;
if (col_span == 1 && w_pref > pref_widths[col])
pref_widths[col] = w_pref;
}
total_min_width = (priv->n_cols - 1) * (float) priv->col_spacing;
total_pref_width = total_min_width;
for (i = 0; i < priv->n_cols; i++)
{
total_min_width += min_widths[i];
total_pref_width += pref_widths[i];
}
/* If we were requested width-for-height, then we reported minimum/natural
* heights based on our natural width. If we were allocated less than our
* natural width, then we need more height. So in the width-for-height
* case we need to disable shrinking.
*/
if (for_height >= 0)
total_min_width = total_pref_width;
if (min_width_p)
*min_width_p = total_min_width;
if (natural_width_p)
*natural_width_p = total_pref_width;
st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);
}
static void
scroll_bar_allocate_children (StScrollBar *bar,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StScrollBarPrivate *priv = bar->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (bar));
ClutterActorBox content_box, bw_box, fw_box, trough_box;
gfloat bw_stepper_size, fw_stepper_size, min_size, natural_size;
st_theme_node_get_content_box (theme_node, box, &content_box);
if (priv->vertical)
{
gfloat width = content_box.x2 - content_box.x1;
clutter_actor_get_preferred_height (priv->bw_stepper, width,
&min_size, &natural_size);
bw_stepper_size = MAX (min_size, natural_size);
/* Backward stepper */
bw_box.x1 = content_box.x1;
bw_box.y1 = content_box.y1;
bw_box.x2 = content_box.x2;
bw_box.y2 = bw_box.y1 + bw_stepper_size;
clutter_actor_allocate (priv->bw_stepper, &bw_box, flags);
clutter_actor_get_preferred_height (priv->fw_stepper, width,
&min_size, &natural_size);
fw_stepper_size = MAX (min_size, natural_size);
/* Forward stepper */
fw_box.x1 = content_box.x1;
fw_box.y1 = content_box.y2 - fw_stepper_size;
fw_box.x2 = content_box.x2;
fw_box.y2 = content_box.y2;
clutter_actor_allocate (priv->fw_stepper, &fw_box, flags);
/* Trough */
trough_box.x1 = content_box.x1;
trough_box.y1 = content_box.y1 + bw_stepper_size;
trough_box.x2 = content_box.x2;
trough_box.y2 = content_box.y2 - fw_stepper_size;
clutter_actor_allocate (priv->trough, &trough_box, flags);
}
else
{
gfloat height = content_box.y2 - content_box.y1;
clutter_actor_get_preferred_width (priv->bw_stepper, height,
&min_size, &natural_size);
bw_stepper_size = MAX (min_size, natural_size);
/* Backward stepper */
bw_box.x1 = content_box.x1;
bw_box.y1 = content_box.y1;
bw_box.x2 = bw_box.x1 + bw_stepper_size;
bw_box.y2 = content_box.y2;
clutter_actor_allocate (priv->bw_stepper, &bw_box, flags);
clutter_actor_get_preferred_width (priv->fw_stepper, height,
&min_size, &natural_size);
fw_stepper_size = MAX (min_size, natural_size);
/* Forward stepper */
fw_box.x1 = content_box.x2 - fw_stepper_size;
fw_box.y1 = content_box.y1;
fw_box.x2 = content_box.x2;
fw_box.y2 = content_box.y2;
clutter_actor_allocate (priv->fw_stepper, &fw_box, flags);
/* Trough */
trough_box.x1 = content_box.x1 + bw_stepper_size;
trough_box.y1 = content_box.y1;
trough_box.x2 = content_box.x2 - fw_stepper_size;
trough_box.y2 = content_box.y2;
clutter_actor_allocate (priv->trough, &trough_box, flags);
}
if (priv->adjustment)
{
float handle_size, position, avail_size, stepper_size;
gdouble value, lower, upper, page_size, increment, min_size, max_size;
ClutterActorBox handle_box = { 0, };
stepper_size = bw_stepper_size + fw_stepper_size;
st_adjustment_get_values (priv->adjustment,
&value,
&lower,
&upper,
NULL,
NULL,
&page_size);
if ((upper == lower)
|| (page_size >= (upper - lower)))
increment = 1.0;
else
increment = page_size / (upper - lower);
min_size = 32.;
st_theme_node_lookup_length (theme_node, "min-size", FALSE, &min_size);
max_size = G_MAXINT16;
st_theme_node_lookup_length (theme_node, "max-size", FALSE, &max_size);
if (upper - lower - page_size <= 0)
position = 0;
else
position = (value - lower) / (upper - lower - page_size);
if (priv->vertical)
{
avail_size = content_box.y2 - content_box.y1 - stepper_size;
handle_size = increment * avail_size;
handle_size = CLAMP (handle_size, min_size, max_size);
handle_box.x1 = content_box.x1;
handle_box.y1 = bw_box.y2 + position * (avail_size - handle_size);
handle_box.x2 = content_box.x2;
handle_box.y2 = handle_box.y1 + handle_size;
}
else
{
avail_size = content_box.x2 - content_box.x1 - stepper_size;
handle_size = increment * avail_size;
handle_size = CLAMP (handle_size, min_size, max_size);
handle_box.x1 = bw_box.x2 + position * (avail_size - handle_size);
handle_box.y1 = content_box.y1;
handle_box.x2 = handle_box.x1 + handle_size;
handle_box.y2 = content_box.y2;
}
/* snap to pixel */
handle_box.x1 = (int) handle_box.x1;
handle_box.y1 = (int) handle_box.y1;
handle_box.x2 = (int) handle_box.x2;
handle_box.y2 = (int) handle_box.y2;
clutter_actor_allocate (priv->handle,
&handle_box,
flags);
}
}
static void
st_table_get_preferred_height (ClutterActor *self,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
gint *min_heights, *pref_heights;
gfloat total_min_height, total_pref_height;
StTablePrivate *priv = ST_TABLE (self)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
gint i;
gint *min_widths;
ClutterActor *child;
/* We only support height-for-width allocation. So if we are called
* width-for-height, calculate heights based on our natural width
*/
if (for_width < 0)
{
float natural_width;
clutter_actor_get_preferred_width (self, -1, NULL, &natural_width);
for_width = natural_width;
}
if (priv->n_rows < 1)
{
*min_height_p = 0;
*natural_height_p = 0;
return;
}
st_theme_node_adjust_for_width (theme_node, &for_width);
/* Setting size to zero and then what we want it to be causes a clear if
* clear flag is set (which it should be.)
*/
g_array_set_size (priv->min_heights, 0);
g_array_set_size (priv->pref_heights, 0);
g_array_set_size (priv->min_heights, priv->n_rows);
g_array_set_size (priv->pref_heights, priv->n_rows);
/* use min_widths to help allocation of height-for-width widgets */
min_widths = st_table_calculate_col_widths (ST_TABLE (self), for_width);
min_heights = (gint *) priv->min_heights->data;
pref_heights = (gint *) priv->pref_heights->data;
/* calculate minimum row heights */
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint row, col, col_span, cell_width, row_span;
gfloat min, pref;
StTableChild *meta;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
row = meta->row;
col = meta->col;
col_span = meta->col_span;
row_span = meta->row_span;
cell_width = 0;
for (i = 0; i < col_span && col + i < priv->n_cols; i++)
cell_width += min_widths[col + i];
_st_actor_get_preferred_height (child, (float) cell_width, meta->x_fill,
&min, &pref);
if (row_span == 1 && min > min_heights[row])
min_heights[row] = min;
if (row_span == 1 && pref > pref_heights[row])
pref_heights[row] = pref;
}
/* start off with row spacing */
total_min_height = (priv->n_rows - 1) * (float) (priv->row_spacing);
total_pref_height = total_min_height;
for (i = 0; i < priv->n_rows; i++)
{
total_min_height += min_heights[i];
total_pref_height += pref_heights[i];
}
if (min_height_p)
*min_height_p = total_min_height;
if (natural_height_p)
*natural_height_p = total_pref_height;
st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);
}
static void
st_scroll_view_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
StScrollViewPrivate *priv = ST_SCROLL_VIEW (actor)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
gboolean account_for_vscrollbar = FALSE;
gfloat min_width = 0, natural_width;
gfloat child_min_width, child_natural_width;
if (!priv->child)
return;
st_theme_node_adjust_for_height (theme_node, &for_height);
clutter_actor_get_preferred_width (priv->child, -1,
&child_min_width, &child_natural_width);
natural_width = child_natural_width;
switch (priv->hscrollbar_policy)
{
case GTK_POLICY_NEVER:
min_width = child_min_width;
break;
case GTK_POLICY_ALWAYS:
case GTK_POLICY_AUTOMATIC:
/* Should theoretically use the min width of the hscrollbar,
* but that's not cleanly defined at the moment */
min_width = 0;
break;
}
switch (priv->vscrollbar_policy)
{
case GTK_POLICY_NEVER:
account_for_vscrollbar = FALSE;
break;
case GTK_POLICY_ALWAYS:
account_for_vscrollbar = !priv->overlay_scrollbars;
break;
case GTK_POLICY_AUTOMATIC:
/* For automatic scrollbars, we always request space for the vertical
* scrollbar; we won't know whether we actually need one until our
* height is assigned in allocate().
*/
account_for_vscrollbar = !priv->overlay_scrollbars;
break;
}
if (account_for_vscrollbar)
{
float sb_width = get_scrollbar_width (ST_SCROLL_VIEW (actor), for_height);
min_width += sb_width;
natural_width += sb_width;
}
if (min_width_p)
*min_width_p = min_width;
if (natural_width_p)
*natural_width_p = natural_width;
st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);
}
static void
st_table_preferred_allocate (ClutterActor *self,
const ClutterActorBox *content_box,
gboolean flags)
{
GList *list, *children;
gint row_spacing, col_spacing;
gint i;
StTable *table;
StTablePrivate *priv;
gboolean ltr;
DimensionData *rows, *columns;
table = ST_TABLE (self);
priv = ST_TABLE (self)->priv;
col_spacing = (priv->col_spacing);
row_spacing = (priv->row_spacing);
st_table_calculate_dimensions (table,
content_box->x2 - content_box->x1,
content_box->y2 - content_box->y1);
ltr = (st_widget_get_direction (ST_WIDGET (self)) == ST_TEXT_DIRECTION_LTR);
rows = &g_array_index (priv->rows, DimensionData, 0);
columns = &g_array_index (priv->columns, DimensionData, 0);
children = st_container_get_children_list (ST_CONTAINER (self));
for (list = children; list; list = list->next)
{
gint row, col, row_span, col_span;
gint col_width, row_height;
StTableChild *meta;
ClutterActor *child;
ClutterActorBox childbox;
gint child_x, child_y;
StAlign x_align, y_align;
gboolean x_fill, y_fill;
child = CLUTTER_ACTOR (list->data);
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
row_span = meta->row_span;
col_span = meta->col_span;
x_align = meta->x_align;
y_align = meta->y_align;
x_fill = meta->x_fill;
y_fill = meta->y_fill;
/* initialise the width and height */
col_width = columns[col].final_size;
row_height = rows[row].final_size;
/* Add the widths of the spanned columns:
*
* First check that we have a non-zero span. Then we loop over each of
* the columns that we're spanning but we stop short if we go past the
* number of columns in the table. This is necessary to avoid accessing
* uninitialised memory. We add the spacing in here too since we only
* want to add as much spacing as times we successfully span.
*/
if (col + col_span > priv->n_cols)
g_warning ("StTable: the child at %d,%d's col-span, %d, exceeds number of columns, %d",
col, row, col_span, priv->n_cols);
if (row + row_span > priv->n_rows)
g_warning ("StTable: the child at %d,%d's row-span, %d, exceeds number of rows, %d",
col, row, row_span, priv->n_rows);
if (col_span > 1)
{
for (i = col + 1; i < col + col_span && i < priv->n_cols; i++)
{
col_width += columns[i].final_size;
col_width += col_spacing;
}
}
/* add the height of the spanned rows */
if (row_span > 1)
{
for (i = row + 1; i < row + row_span && i < priv->n_rows; i++)
{
row_height += rows[i].final_size;
row_height += row_spacing;
}
}
/* calculate child x */
if (ltr)
{
child_x = (int) content_box->x1
+ col_spacing * col;
for (i = 0; i < col; i++)
child_x += columns[i].final_size;
}
else
{
child_x = (int) content_box->x2
- col_spacing * col;
for (i = 0; i < col; i++)
child_x -= columns[i].final_size;
}
/* calculate child y */
child_y = (int) content_box->y1
+ row_spacing * row;
for (i = 0; i < row; i++)
child_y += rows[i].final_size;
/* set up childbox */
if (ltr)
{
childbox.x1 = (float) child_x;
childbox.x2 = (float) MAX (0, child_x + col_width);
}
else
{
childbox.x2 = (float) child_x;
childbox.x1 = (float) MAX (0, child_x - col_width);
}
childbox.y1 = (float) child_y;
childbox.y2 = (float) MAX (0, child_y + row_height);
_st_allocate_fill (ST_WIDGET (self), child, &childbox,
x_align, y_align, x_fill, y_fill);
clutter_actor_allocate (child, &childbox, flags);
}
}
