static void
mpl_entry_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
MplEntryPrivate *priv = MPL_ENTRY (actor)->priv;
MxPadding padding = { 0, 0, 0, 0 };
gfloat min_width_entry, min_width_button;
gfloat natural_width_entry, natural_width_button;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
clutter_actor_get_preferred_width (priv->entry, for_height,
&min_width_entry,
&natural_width_entry);
clutter_actor_get_preferred_width (priv->table, for_height,
&min_width_button,
&natural_width_button);
if (min_width_p)
*min_width_p = padding.left +
min_width_entry +
min_width_button +
padding.right;
if (natural_width_p)
*natural_width_p = padding.left +
natural_width_entry +
natural_width_button +
padding.right;
}
static void
ntf_overlay_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
NtfOverlayPrivate *priv = NTF_OVERLAY (actor)->priv;
ClutterActorClass *klass;
gfloat my_width, my_height;
ClutterActor *tna = CLUTTER_ACTOR (priv->tray_normal);
ClutterActor *tua = CLUTTER_ACTOR (priv->tray_urgent);
ClutterActor *lowlight = priv->lowlight;
klass = CLUTTER_ACTOR_CLASS (ntf_overlay_parent_class);
klass->allocate (actor, box, flags);
my_width = box->x2 - box->x1;
my_height = box->y2 - box->y1;
{
ClutterActorBox tray_box;
gfloat p_width, p_height, m_width, m_height;
clutter_actor_get_preferred_width (tna, -1.0, &m_width, &p_width);
clutter_actor_get_preferred_height (tna, p_width, &m_height, &p_height);
tray_box.x1 = my_width - p_width;
tray_box.y1 = my_height - p_height;
tray_box.x2 = tray_box.x1 + p_width;
tray_box.y2 = tray_box.y1 + p_height;
clutter_actor_allocate (tna, &tray_box, flags);
}
{
ClutterActorBox tray_box;
gfloat p_width, p_height, m_width, m_height;
clutter_actor_get_preferred_width (tua, -1.0, &m_width, &p_width);
clutter_actor_get_preferred_height (tua, p_width, &m_height, &p_height);
tray_box.x1 = (gint)((my_width - p_width) / 2.0);
tray_box.y1 = (gint)((my_height - p_height) / 2.0);
tray_box.x2 = tray_box.x1 + p_width;
tray_box.y2 = tray_box.y1 + p_height;
clutter_actor_allocate (tua, &tray_box, flags);
}
{
ClutterActorBox lowlight_box;
lowlight_box.x1 = 0.0;
lowlight_box.y1 = 0.0;
lowlight_box.x2 = my_width;
lowlight_box.y2 = my_height;
clutter_actor_allocate (lowlight, &lowlight_box, flags);
}
}
static void
mex_content_box_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width,
gfloat *pref_width)
{
MexContentBoxPrivate *priv = MEX_CONTENT_BOX (actor)->priv;
gfloat list_w;
clutter_actor_get_preferred_width (priv->tile, for_height, min_width,
pref_width);
if (!priv->extras_visible)
return;
if (pref_width)
{
clutter_actor_get_preferred_width (priv->action_list, for_height, NULL,
&list_w);
if (clutter_timeline_is_playing (priv->timeline))
*pref_width = *pref_width +
(list_w * clutter_alpha_get_alpha (priv->alpha));
else
*pref_width = *pref_width + list_w;
}
}
static void
mex_column_view_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
MxPadding padding;
gfloat min_width, nat_width;
gfloat min_header, nat_header;
gfloat min_placeholder, nat_placeholder;
gfloat height;
MexColumnView *self = MEX_COLUMN_VIEW (actor);
MexColumnViewPrivate *priv = self->priv;
clutter_actor_get_preferred_width (priv->header,
-1,
&min_header,
&nat_header);
clutter_actor_get_preferred_height (priv->header, -1, NULL, &height);
for_height = MAX (0, for_height - height);
if (mex_column_is_empty (MEX_COLUMN (priv->column)))
{
if (priv->placeholder_actor)
{
clutter_actor_get_preferred_width (priv->placeholder_actor,
for_height,
&min_placeholder,
&nat_placeholder);
min_width = MAX (min_header, min_placeholder);
nat_width = MAX (min_header, nat_placeholder);
}
else
{
min_width = min_header;
nat_width = nat_header;
}
}
else
{
clutter_actor_get_preferred_width (priv->scroll,
for_height,
&min_placeholder,
&nat_placeholder);
min_width = MAX (min_header, min_placeholder);
nat_width = MAX (min_header, nat_placeholder);
}
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (min_width_p)
*min_width_p = min_width + padding.left + padding.right;
if (nat_width_p)
*nat_width_p = nat_width + padding.left + padding.right;
}
static void
mpl_application_view_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MplApplicationViewPrivate *priv = ((MplApplicationView *) actor)->priv;
MxPadding padding;
ClutterActorBox child_box;
gfloat icon_width = 0, icon_height = 0, button_width, button_height;
CLUTTER_ACTOR_CLASS (mpl_application_view_parent_class)->allocate (actor,
box,
flags);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
/* Icon */
child_box.x1 = padding.left;
child_box.y1 = padding.top;
if (priv->icon)
{
clutter_actor_get_preferred_width (priv->icon, -1, NULL, &icon_width);
clutter_actor_get_preferred_height (priv->icon, -1, NULL, &icon_height);
child_box.x2 = child_box.x1 + icon_width;
child_box.y2 = child_box.y1 + icon_height;
clutter_actor_allocate (priv->icon, &child_box, flags);
}
/* Close button */
clutter_actor_get_preferred_width (priv->close_button, -1, NULL, &button_width);
clutter_actor_get_preferred_height (priv->close_button, -1, NULL, &button_height);
child_box.x2 = box->x2 - box->x1 - padding.right;
child_box.y2 = child_box.y1 + button_height;
child_box.x1 = child_box.x2 - button_width;
clutter_actor_allocate (priv->close_button, &child_box, flags);
/* Titles */
child_box.x1 = padding.left + icon_width;
child_box.x2 = box->x2 - box->x1 - padding.right - button_width;
child_box.y2 = padding.top + icon_height;
clutter_actor_allocate (priv->title_box, &child_box, flags);
/* App frame */
child_box.x1 = padding.left;
child_box.x2 = box->x2 - box->x1 - padding.right;
child_box.y1 = padding.top + icon_width;
child_box.y2 = box->y2 - box->y1 - padding.bottom;
clutter_actor_allocate (priv->app_frame, &child_box, flags);
}
static void
mex_content_box_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MexContentBoxPrivate *priv = MEX_CONTENT_BOX (actor)->priv;
ClutterActorBox child_box;
gfloat pref_w = 0, pref_h = 0, tile_w, tile_h;
CLUTTER_ACTOR_CLASS (mex_content_box_parent_class)->allocate (actor, box,
flags);
tile_w = box->x2 - box->x1;
clutter_actor_get_preferred_width (priv->tile, -1, NULL, &tile_w);
if (tile_w > box->x2 - box->x1)
tile_w = box->x2 - box->x1;
clutter_actor_get_preferred_height (priv->tile, tile_w, NULL, &tile_h);
child_box.x1 = 0;
child_box.x2 = child_box.x1 + tile_w;
child_box.y1 = 0;
child_box.y2 = child_box.y1 + tile_h;
clutter_actor_allocate (priv->tile, &child_box, flags);
if (G_UNLIKELY (priv->extras_visible))
{
/* action list */
clutter_actor_get_preferred_width (priv->action_list, -1, NULL, &pref_w);
clutter_actor_get_preferred_height (priv->info_panel, -1, NULL, &pref_h);
child_box.x1 = tile_w;
child_box.x2 = tile_w + pref_w;
child_box.y1 = 0;
child_box.y2 = tile_h;
clutter_actor_allocate (priv->action_list, &child_box, flags);
child_box.x1 = 0;
child_box.x2 = tile_w + pref_w;
child_box.y1 = tile_h;
child_box.y2 = tile_h + pref_h;
clutter_actor_allocate (priv->info_panel, &child_box, flags);
}
/* enable clip-to-allocation if the children will extend beyond the allocated
* box */
if ((tile_w + pref_w) > (box->x2 - box->x1)
|| (tile_h + pref_h) > (box->y2 - box->y1))
priv->clip_to_allocation = TRUE;
else
priv->clip_to_allocation = FALSE;
}
/* Get width of a child of this actor */
static void _xfdashboard_workspace_selector_get_preferred_width_for_child(XfdashboardWorkspaceSelector *self,
ClutterActor *inChild,
gfloat inForHeight,
gfloat *outMinWidth,
gfloat *outNaturalWidth)
{
XfdashboardWorkspaceSelectorPrivate *priv;
gfloat minWidth, naturalWidth;
gfloat maxSize;
g_return_if_fail(XFDASHBOARD_IS_WORKSPACE_SELECTOR(self));
priv=self->priv;
/* Set up default values */
minWidth=naturalWidth=0.0f;
/* Determine width for horizontal orientation ... */
if(priv->orientation==CLUTTER_ORIENTATION_HORIZONTAL)
{
/* Adjust requested height to maximum height */
maxSize=_xfdashboard_workspace_selector_get_max_size_internal(self)-(2*priv->spacing);
if(maxSize>=0.0f && inForHeight>maxSize) inForHeight=maxSize;
/* Get width of child */
clutter_actor_get_preferred_width(inChild, inForHeight, &minWidth, &naturalWidth);
}
/* ... otherwise determine height for vertical orientation */
else
{
/* Get width of child */
clutter_actor_get_preferred_width(inChild, inForHeight, &minWidth, &naturalWidth);
/* Adjust child's width to maximum width */
maxSize=_xfdashboard_workspace_selector_get_max_size_internal(self)-(2*priv->spacing);
if(maxSize>=0.0)
{
/* Adjust minimum width if it exceed limit */
if(minWidth>maxSize) minWidth=maxSize;
/* Adjust natural width if it exceed limit */
if(naturalWidth>maxSize) naturalWidth=maxSize;
}
}
/* Store sizes computed */
if(outMinWidth) *outMinWidth=minWidth;
if(outNaturalWidth) *outNaturalWidth=naturalWidth;
}
static void
mx_progress_bar_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
MxPadding padding;
MxProgressBarPrivate *priv = MX_PROGRESS_BAR (actor)->priv;
gfloat height;
clutter_actor_get_preferred_width (priv->fill,
for_height,
min_width_p,
nat_width_p);
clutter_actor_get_preferred_height (priv->fill,
-1,
&height,
NULL);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (min_width_p)
*min_width_p += padding.left + padding.right;
/* Add an arbitrary amount to the width for preferred width, so that the
* indicator is visible and can display some values */
if (nat_width_p)
*nat_width_p += padding.left + padding.right + height * 4;
}
static void
mx_label_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
MxLabelPrivate *priv = MX_LABEL (actor)->priv;
MxPadding padding = { 0, };
mx_widget_get_padding (MX_WIDGET (actor), &padding);
for_height -= padding.top + padding.bottom;
clutter_actor_get_preferred_width (priv->label, for_height,
min_width_p,
natural_width_p);
/* If we're fading out, make sure our minimum width is zero */
if (priv->fade_out && min_width_p)
*min_width_p = 0;
if (min_width_p)
*min_width_p += padding.left + padding.right;
if (natural_width_p)
*natural_width_p += padding.left + padding.right;
}
static void
mnb_fancy_bin_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
MxPadding padding;
MnbFancyBinPrivate *priv = MNB_FANCY_BIN (actor)->priv;
if (min_width_p)
*min_width_p = 0;
if (nat_width_p)
*nat_width_p = 0;
if (priv->real_child)
clutter_actor_get_preferred_width (priv->real_child,
for_height,
min_width_p,
nat_width_p);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (min_width_p)
*min_width_p += padding.left + padding.right;
if (nat_width_p)
*nat_width_p += padding.left + padding.right;
}
static void
mx_toggle_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *pref_width_p)
{
ClutterActor *background;
gfloat pref_w;
background = mx_widget_get_background_image (MX_WIDGET (actor));
if (!background)
{
if (min_width_p)
*min_width_p = 0;
if (pref_width_p)
*pref_width_p = 0;
return;
}
clutter_actor_get_preferred_width (background, -1, NULL, &pref_w);
if (min_width_p)
*min_width_p = pref_w;
if (pref_width_p)
*pref_width_p = pref_w;
}
static void
clutter_bin_layout_get_preferred_width (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
ClutterActor *actor = CLUTTER_ACTOR (container);
ClutterActorIter iter;
ClutterActor *child;
gfloat min_width, nat_width;
min_width = nat_width = 0.0;
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
{
gfloat minimum, natural;
clutter_actor_get_preferred_width (child, for_height,
&minimum,
&natural);
min_width = MAX (min_width, minimum);
nat_width = MAX (nat_width, natural);
}
if (min_width_p)
*min_width_p = min_width;
if (nat_width_p)
*nat_width_p = nat_width;
}
static void
ntf_tray_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width,
gfloat *nat_width)
{
NtfTrayPrivate *priv = NTF_TRAY (actor)->priv;
if (min_width)
*min_width = CLUSTER_WIDTH;
if (nat_width)
{
if (priv->urgent)
{
gfloat nat_notif;
MetaPlugin *plugin = dawati_netbook_get_plugin_singleton ();
MetaScreen *screen = meta_plugin_get_screen (plugin);
gint screen_width, screen_height;
meta_screen_get_size (screen, &screen_width, &screen_height);
clutter_actor_get_preferred_width (priv->notifiers, for_height,
NULL, &nat_notif);
*nat_width = MIN ((2 * screen_width) / 3, nat_notif);
}
else
*nat_width = CLUSTER_WIDTH;
}
}
static void
clutter_bin_layout_get_preferred_width (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
GList *children = clutter_container_get_children (container);
GList *l;
gfloat min_width, nat_width;
min_width = nat_width = 0.0;
for (l = children; l != NULL; l = l->next)
{
ClutterActor *child = l->data;
gfloat minimum, natural;
clutter_actor_get_preferred_width (child, for_height,
&minimum,
&natural);
min_width = MAX (min_width, minimum);
nat_width = MAX (nat_width, natural);
}
if (min_width_p)
*min_width_p = min_width;
if (nat_width_p)
*nat_width_p = nat_width;
}
static void
mex_clock_bin_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
MxPadding padding;
gfloat min_width, nat_width;
MexClockBinPrivate *priv = MEX_CLOCK_BIN (actor)->priv;
CLUTTER_ACTOR_CLASS (mex_clock_bin_parent_class)->
get_preferred_width (actor, for_height, min_width_p, nat_width_p);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (for_height >= 0)
for_height = MAX (0, for_height - padding.top - padding.bottom);
clutter_actor_get_preferred_width (priv->clock_hbox,
for_height,
&min_width,
&nat_width);
min_width += padding.left + padding.right;
nat_width += padding.left + padding.right;
if (min_width_p && (*min_width_p < min_width))
*min_width_p = min_width;
if (nat_width_p && (*nat_width_p < nat_width))
*nat_width_p = nat_width;
}
static void
mx_button_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width,
gfloat *pref_width)
{
MxButtonPrivate *priv = MX_BUTTON (actor)->priv;
if (priv->content_image)
{
gfloat width;
clutter_actor_get_preferred_width (priv->content_image, for_height,
NULL, &width);
if (min_width)
*min_width = width;
if (pref_width)
*pref_width = width;
return;
}
CLUTTER_ACTOR_CLASS (mx_button_parent_class)->get_preferred_width (actor,
for_height,
min_width,
pref_width);
}
static void
mx_frame_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width,
gfloat *pref_width)
{
MxFramePrivate *priv = ((MxFrame *) actor)->priv;
MxPadding padding;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (min_width)
*min_width = 0;
if (pref_width)
*pref_width = 0;
if (priv->child)
{
clutter_actor_get_preferred_width (priv->child,
for_height - padding.top - padding.bottom,
min_width, pref_width);
}
if (min_width)
*min_width += padding.left + padding.right;
if (pref_width)
*pref_width += padding.left + padding.right;
}
static void
mx_toolbar_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width,
gfloat *pref_width)
{
MxToolbarPrivate *priv = MX_TOOLBAR (actor)->priv;
MxPadding padding;
gfloat min_child, pref_child, min_close, pref_close;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
for_height = for_height - padding.top - padding.bottom;
if (priv->has_close_button && priv->close_button)
{
clutter_actor_get_preferred_width (priv->close_button,
for_height,
&min_close,
&pref_close);
}
else
{
min_close = 0;
pref_close = 0;
}
if (priv->child)
{
clutter_actor_get_preferred_width (priv->child,
for_height,
&min_child,
&pref_child);
}
else
{
min_child = 0;
pref_child = 0;
}
if (min_width)
*min_width = padding.left + padding.right + min_close + min_child + SPACING;
if (pref_width)
*pref_width = padding.left + padding.right + pref_close + pref_child + SPACING;
}
static void
mx_toggle_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MxTogglePrivate *priv = MX_TOGGLE (actor)->priv;
ClutterActorBox handle_box, child_box;
ClutterActor *background;
gfloat handle_w;
gfloat toggle_pos;
CLUTTER_ACTOR_CLASS (mx_toggle_parent_class)->allocate (actor, box, flags);
mx_widget_get_available_area (MX_WIDGET (actor), box, &child_box);
/* background-image don't get stretched, so adjust the child box so that the
* handle appears in the correct place.
*/
background = mx_widget_get_background_image (MX_WIDGET (actor));
if (background)
{
gfloat width;
MxPadding padding;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
clutter_actor_get_preferred_width (background, -1, NULL, &width);
width -= padding.left + padding.right;
child_box.x1 += (child_box.x2 - child_box.x1) / 2.f;
child_box.x1 -= width / 2.f;
child_box.x2 = child_box.x1 + width;
}
clutter_actor_get_preferred_width (priv->handle, -1, NULL, &handle_w);
toggle_pos = child_box.x2 - handle_w - child_box.x1;
priv->slide_length = toggle_pos;
toggle_pos = toggle_pos * priv->position;
handle_box.x1 = (gint) (child_box.x1 + toggle_pos);
handle_box.y1 = child_box.y1;
handle_box.x2 = handle_box.x1 + handle_w;
handle_box.y2 = child_box.y2;
clutter_actor_allocate (priv->handle, &handle_box, flags);
}
static void
mx_expander_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width,
gfloat *pref_width)
{
MxExpanderPrivate *priv = MX_EXPANDER (actor)->priv;
ClutterActor *child;
MxPadding padding;
gfloat min_child_w, pref_child_w, min_label_w, pref_label_w, arrow_w;
child = mx_bin_get_child (MX_BIN (actor));
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (child)
{
clutter_actor_get_preferred_width (child,
-1,
&min_child_w,
&pref_child_w);
}
else
{
min_child_w = 0;
pref_child_w = 0;
}
clutter_actor_get_preferred_width (priv->label,
-1, &min_label_w, &pref_label_w);
clutter_actor_get_preferred_width (priv->arrow,
-1, NULL, &arrow_w);
/* TODO: create a style property for this padding between arrow and label */
if (arrow_w)
arrow_w += 6.0f;
if (min_width)
*min_width = padding.left
+ MAX (min_child_w, min_label_w + arrow_w)
+ padding.right;
if (pref_width)
*pref_width = padding.left
+ MAX (pref_child_w, pref_label_w + arrow_w)
+ padding.right;
}
static void
ckd_slide_get_preferred_width (ClutterActor *a, gfloat for_h, gfloat *min_w, gfloat *natural_w)
{
CkdSlide *self = CKD_SLIDE (a);
CkdSlidePriv *priv = CKD_SLIDE_GET_PRIVATE (self);
clutter_actor_get_preferred_width (priv->content, for_h, min_w, natural_w);
}
static void
mx_tooltip_get_preferred_width (ClutterActor *self,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
MxTooltipPrivate *priv = MX_TOOLTIP (self)->priv;
gfloat min_label_w, natural_label_w;
gfloat label_height, arrow_height;
CoglHandle arrow_image;
MxPadding padding;
mx_widget_get_padding (MX_WIDGET (self), &padding);
arrow_image = mx_widget_get_background_texture (MX_WIDGET (self));
if (arrow_image)
{
arrow_height = cogl_texture_get_height (arrow_image);
}
else
{
arrow_height = 0;
}
if (for_height > -1)
{
label_height = for_height - arrow_height - padding.top - padding.bottom;
}
else
{
label_height = -1;
}
if (priv->label)
{
clutter_actor_get_preferred_width (priv->label,
label_height,
&min_label_w,
&natural_label_w);
}
else
{
min_label_w = 0;
natural_label_w = 0;
}
if (min_width_p)
{
*min_width_p = padding.left + padding.right + min_label_w;
}
if (natural_width_p)
{
*natural_width_p = padding.left + padding.right + natural_label_w;
}
}
static void
st_table_get_preferred_height (ClutterActor *self,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
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;
DimensionData *rows;
/* 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);
/* use min_widths to help allocation of height-for-width widgets */
st_table_calculate_dimensions (ST_TABLE (self), for_width, -1);
rows = &g_array_index (priv->rows, DimensionData, 0);
/* start off with row spacing */
total_min_height = (priv->visible_rows - 1) * (float)(priv->row_spacing);
total_pref_height = total_min_height;
for (i = 0; i < priv->n_rows; i++)
{
total_min_height += rows[i].min_size;
total_pref_height += rows[i].pref_size;
}
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
mx_scroll_view_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
MxPadding padding;
gfloat child_min_w, child_nat_w;
gfloat vscroll_w;
MxScrollViewPrivate *priv = MX_SCROLL_VIEW (actor)->priv;
if (!priv->child)
return;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
/* Our natural width is the natural width of the child */
clutter_actor_get_preferred_width (priv->child,
for_height,
&child_min_w,
&child_nat_w);
/* Add space for the scroll-bar if we can determine it will be necessary */
vscroll_w = 0;
if (for_height >= 0)
{
gfloat natural_height;
clutter_actor_get_preferred_height (priv->child, -1.0,
NULL,
&natural_height);
if (for_height < natural_height)
vscroll_w = priv->scrollbar_width;
}
if (min_width_p)
{
*min_width_p = padding.left + padding.right + vscroll_w;
/* if the scroll policy is not set to always or horizontal, then the
* minimum size of the scroll view is the minimum size of the child */
if (!(priv->scroll_policy == MX_SCROLL_POLICY_BOTH
|| priv->scroll_policy == MX_SCROLL_POLICY_HORIZONTAL))
{
*min_width_p += child_min_w;
}
}
/* Add space for padding */
if (natural_width_p)
*natural_width_p = padding.left + padding.right + child_nat_w + vscroll_w;
}
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));
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:
case GTK_POLICY_EXTERNAL:
/* Should theoretically use the min width of the hscrollbar,
* but that's not cleanly defined at the moment */
min_width = 0;
break;
default:
g_warn_if_reached();
break;
}
if (priv->vscrollbar_policy != GTK_POLICY_NEVER)
{
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_entry_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
gfloat icon_w;
st_theme_node_adjust_for_height (theme_node, &for_height);
clutter_actor_get_preferred_width (priv->entry, for_height,
min_width_p,
natural_width_p);
if (priv->primary_icon)
{
clutter_actor_get_preferred_width (priv->primary_icon, -1, NULL, &icon_w);
if (min_width_p)
*min_width_p += icon_w + priv->spacing;
if (natural_width_p)
*natural_width_p += icon_w + priv->spacing;
}
if (priv->secondary_icon)
{
clutter_actor_get_preferred_width (priv->secondary_icon,
-1, NULL, &icon_w);
if (min_width_p)
*min_width_p += icon_w + priv->spacing;
if (natural_width_p)
*natural_width_p += icon_w + priv->spacing;
}
st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);
}
/* Allocate position and size of actor and its children */
static void _xfdashboard_workspace_selector_allocate(ClutterActor *inActor,
const ClutterActorBox *inBox,
ClutterAllocationFlags inFlags)
{
XfdashboardWorkspaceSelector *self=XFDASHBOARD_WORKSPACE_SELECTOR(inActor);
XfdashboardWorkspaceSelectorPrivate *priv=self->priv;
gfloat availableWidth, availableHeight;
gfloat childWidth, childHeight;
ClutterActor *child;
ClutterActorIter iter;
ClutterActorBox childAllocation={ 0, };
/* Chain up to store the allocation of the actor */
CLUTTER_ACTOR_CLASS(xfdashboard_workspace_selector_parent_class)->allocate(inActor, inBox, inFlags);
/* Get available size */
clutter_actor_box_get_size(inBox, &availableWidth, &availableHeight);
/* Calculate new position and size of visible children */
childAllocation.x1=childAllocation.y1=priv->spacing;
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(inActor));
while(clutter_actor_iter_next(&iter, &child))
{
/* Is child visible? */
if(!CLUTTER_ACTOR_IS_VISIBLE(child)) continue;
/* Calculate new position and size of child */
if(priv->orientation==CLUTTER_ORIENTATION_HORIZONTAL)
{
childHeight=availableHeight-(2*priv->spacing);
clutter_actor_get_preferred_width(child, childHeight, NULL, &childWidth);
childAllocation.y1=ceil(MAX(((availableHeight-childHeight))/2.0f, priv->spacing));
childAllocation.y2=floor(childAllocation.y1+childHeight);
childAllocation.x2=floor(childAllocation.x1+childWidth);
}
else
{
childWidth=availableWidth-(2*priv->spacing);
clutter_actor_get_preferred_height(child, childWidth, NULL, &childHeight);
childAllocation.x1=ceil(MAX(((availableWidth-childWidth))/2.0f, priv->spacing));
childAllocation.x2=floor(childAllocation.x1+childWidth);
childAllocation.y2=floor(childAllocation.y1+childHeight);
}
clutter_actor_allocate(child, &childAllocation, inFlags);
/* Set up for next child */
if(priv->orientation==CLUTTER_ORIENTATION_HORIZONTAL) childAllocation.x1=floor(childAllocation.x1+childWidth+priv->spacing);
else childAllocation.y1=floor(childAllocation.y1+childHeight+priv->spacing);
}
}
void
mex_telepathy_channel_set_tool_mode (MexTelepathyChannel *self,
MexToolMode mode,
guint duration)
{
MexTelepathyChannelPrivate *priv = self->priv;
gfloat height;
gfloat width;
gfloat pref_height;
gfloat pref_width;
/* Get natural width and height to calculate aspect ratio */
clutter_actor_get_preferred_height (priv->full_frame,
-1,
NULL,
&pref_height);
clutter_actor_get_preferred_width (priv->full_frame,
-1,
NULL,
&pref_width);
if (mode == TOOL_MODE_PIP)
{
width = priv->scene_width * 0.25;
height = width * (pref_height / pref_width);
/* Hide the toolbar and preview areas */
clutter_actor_hide (priv->toolbar_area);
clutter_actor_hide (priv->preview_area);
}
else if (mode == TOOL_MODE_FULL)
{
height = priv->scene_height * 0.90;
width = height * (pref_width / pref_height);
/* Show the toolbar and preview areas */
clutter_actor_show (priv->toolbar_area);
clutter_actor_show (priv->preview_area);
}
else if (mode == TOOL_MODE_SBS)
{
width = priv->scene_width * 0.50;
height = width * (pref_height / pref_width);
/* Show the toolbar and preview areas */
clutter_actor_hide (priv->toolbar_area);
clutter_actor_hide (priv->preview_area);
}
clutter_actor_animate (priv->full_frame, CLUTTER_EASE_IN_CUBIC,
duration,
"width", width,
"height", height,
NULL);
}
static void
get_preferred_width (ClutterActor *self,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
ChamplainTilePrivate *priv = GET_PRIVATE (self);
clutter_actor_get_preferred_width (CLUTTER_ACTOR (priv->content_group),
for_height,
min_width_p,
natural_width_p);
}
static void
mx_scroll_view_get_preferred_height (ClutterActor *actor,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
MxPadding padding;
gfloat min_child_h, nat_child_h;
gfloat scroll_h;
MxScrollViewPrivate *priv = MX_SCROLL_VIEW (actor)->priv;
if (!priv->child)
return;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
/* Our natural height is the natural height of the child */
clutter_actor_get_preferred_height (priv->child,
for_width,
&min_child_h,
&nat_child_h);
/* Add space for the scroll-bar if we can determine it will be necessary */
scroll_h = 0;
if (for_width >= 0)
{
gfloat natural_width;
clutter_actor_get_preferred_width (priv->child, -1.0,
NULL,
&natural_width);
if (for_width < natural_width)
scroll_h = priv->scrollbar_height;
}
/* Add space for padding */
if (min_height_p)
{
*min_height_p = padding.top + padding.bottom + scroll_h;
if (!(priv->scroll_policy == MX_SCROLL_POLICY_BOTH
|| priv->scroll_policy == MX_SCROLL_POLICY_VERTICAL))
{
*min_height_p += min_child_h;
}
}
if (natural_height_p)
*natural_height_p = padding.top + nat_child_h + padding.bottom + scroll_h;
}
