static void
st_icon_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StIconPrivate *priv = ST_ICON (actor)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
clutter_actor_set_allocation (actor, box, flags);
if (priv->icon_texture)
{
ClutterActorBox content_box;
st_theme_node_get_content_box (theme_node, box, &content_box);
/* Center the texture in the allocation; scaling up the icon from the size
* we loaded it at is just a bad idea and probably accidental. Main downside
* of doing this is that it may not be obvious that they have to turn off
* fill to align the icon non-centered in the parent container.
*
* We don't use clutter_actor_allocate_align_fill() for a bit of efficiency
* and because we expect to get rid of the child actor in favor of a
* CoglTexture in the future.
*/
content_box.x1 = (int)(0.5 + content_box.x1 + (content_box.x2 - content_box.x1 - priv->icon_size) / 2.);
content_box.x2 = content_box.x1 + priv->icon_size;
content_box.y1 = (int)(0.5 + content_box.y1 + (content_box.y2 - content_box.y1 - priv->icon_size) / 2.);
content_box.y2 = content_box.y1 + priv->icon_size;
clutter_actor_allocate (priv->icon_texture, &content_box, flags);
}
}
static void
st_scroll_bar_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StScrollBar *bar = ST_SCROLL_BAR (actor);
clutter_actor_set_allocation (actor, box, flags);
scroll_bar_allocate_children (bar, box, flags);
}
static void
shell_slicer_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
ClutterActor *child;
clutter_actor_set_allocation (self, box, flags);
child = st_bin_get_child (ST_BIN (self));
if (child)
clutter_actor_allocate_preferred_size (child, flags);
}
static void
cinnamon_generic_container_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StThemeNode *theme_node;
ClutterActorBox content_box;
clutter_actor_set_allocation (self, box, flags);
theme_node = st_widget_get_theme_node (ST_WIDGET (self));
st_theme_node_get_content_box (theme_node, box, &content_box);
g_signal_emit (G_OBJECT (self), cinnamon_generic_container_signals[ALLOCATE], 0,
&content_box, flags);
}
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_set_allocation (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
shell_stack_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
ClutterActorBox content_box;
ClutterActor *child;
clutter_actor_set_allocation (self, box, flags);
st_theme_node_get_content_box (theme_node, box, &content_box);
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
ClutterActorBox child_box = content_box;
clutter_actor_allocate (child, &child_box, flags);
}
}
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_scroll_view_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
ClutterActorBox content_box, child_box;
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));
clutter_actor_set_allocation (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_get_text_direction (actor) == CLUTTER_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_get_text_direction (actor) == CLUTTER_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);
/* In case the scrollbar policy is NEVER or scrollbars should be
* overlayed, we don't trim the content box allocation by the
* scrollbar size.
* Fold this into the scrollbar sizes to simplify the rest of the
* computations.
*/
if (priv->hscrollbar_policy == GTK_POLICY_NEVER || priv->overlay_scrollbars)
sb_height = 0;
if (priv->vscrollbar_policy == GTK_POLICY_NEVER || priv->overlay_scrollbars)
sb_width = 0;
/* Child */
if (clutter_actor_get_text_direction (actor) == CLUTTER_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_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;
gint n_expand_children = 0, i;
gfloat expand_amount, shrink_amount;
BoxChildShrink *shrinks = NULL;
// Home-made logical xor
gboolean flip = (!(st_widget_get_direction (ST_WIDGET (actor)) == ST_TEXT_DIRECTION_RTL) != !priv->is_align_end);
gboolean reverse_order = (!priv->is_align_end != !priv->is_pack_start);
ClutterActor *child;
clutter_actor_set_allocation (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;
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 (child = clutter_actor_get_first_child (actor);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
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)
{
if (flip)
{
position = content_box.y2;
}
else
{
position = content_box.y1;
}
}
else
{
if (flip)
{
position = content_box.x2;
}
else
{
position = content_box.x1;
}
}
if (reverse_order)
{
child = clutter_actor_get_last_child (actor);
i = clutter_actor_get_n_children (actor) - 1;
}
else
{
child = clutter_actor_get_first_child (actor);
i = 0;
}
gfloat init_padding = (avail_width/2) - (natural_width/2);
while (child != NULL)
{
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;
}
else {
next_position = position + child_allocated;
}
if (priv->is_vertical)
{
if (flip)
{
child_box.y1 = (int)(0.5 + next_position);
child_box.y2 = (int)(0.5 + position);
}
else
{
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)
{
child_box.x1 = (int)(0.5 + next_position);
child_box.x2 = (int)(0.5 + position);
}
else
{
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 (reverse_order)
{
child = clutter_actor_get_previous_sibling (child);
i--;
}
else
{
child = clutter_actor_get_next_sibling (child);
i++;
}
}
if (shrinks)
g_free (shrinks);
}
