自学教程：C++ st_widget_get_theme_node函数代码示例

static voidst_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 voidst_bin_get_preferred_height (ClutterActor *self,                             gfloat        for_width,                             gfloat       *min_height_p,                             gfloat       *natural_height_p){  StBinPrivate *priv = ST_BIN (self)->priv;  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));  st_theme_node_adjust_for_width (theme_node, &for_width);  if (priv->child == NULL)    {      if (min_height_p)        *min_height_p = 0;      if (natural_height_p)        *natural_height_p = 0;    }  else    {      _st_actor_get_preferred_height (priv->child, for_width, priv->x_fill,                                      min_height_p,                                      natural_height_p);    }  st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);}

static voidst_icon_style_changed (StWidget *widget){  StIcon *self = ST_ICON (widget);  StThemeNode *theme_node = st_widget_get_theme_node (widget);  StIconPrivate *priv = self->priv;  if (priv->shadow_spec)    {      st_shadow_unref (priv->shadow_spec);      priv->shadow_spec = NULL;    }  if (priv->shadow_material)    {      cogl_handle_unref (priv->shadow_material);      priv->shadow_material = COGL_INVALID_HANDLE;    }  priv->shadow_spec = st_theme_node_get_shadow (theme_node, "icon-shadow");  if (priv->shadow_spec && priv->shadow_spec->inset)    {      g_warning ("The icon-shadow property does not support inset shadows");      st_shadow_unref (priv->shadow_spec);      priv->shadow_spec = NULL;    }  priv->theme_icon_size = (int)(0.5 + st_theme_node_get_length (theme_node, "icon-size"));  st_icon_update_icon_size (self);  st_icon_update (self);}

static voidcinnamon_tray_manager_style_changed (StWidget *theme_widget,                                  gpointer  user_data){  CinnamonTrayManager *manager = user_data;  StThemeNode *theme_node;  StIconColors *icon_colors;  GdkColor foreground, warning, error, success;  theme_node = st_widget_get_theme_node (theme_widget);  icon_colors = st_theme_node_get_icon_colors (theme_node);  foreground.red = icon_colors->foreground.red * 0x101;  foreground.green = icon_colors->foreground.green * 0x101;  foreground.blue = icon_colors->foreground.blue * 0x101;  warning.red = icon_colors->warning.red * 0x101;  warning.green = icon_colors->warning.green * 0x101;  warning.blue = icon_colors->warning.blue * 0x101;  error.red = icon_colors->error.red * 0x101;  error.green = icon_colors->error.green * 0x101;  error.blue = icon_colors->error.blue * 0x101;  success.red = icon_colors->success.red * 0x101;  success.green = icon_colors->success.green * 0x101;  success.blue = icon_colors->success.blue * 0x101;  na_tray_manager_set_colors (manager->priv->na_manager,                              &foreground, &warning,                              &error, &success);}

static voidst_entry_style_changed (StWidget *self){  StEntryPrivate *priv = ST_ENTRY_PRIV (self);  StThemeNode *theme_node;  ClutterColor color;  const PangoFontDescription *font;  gchar *font_string;  gdouble size;  theme_node = st_widget_get_theme_node (self);   st_theme_node_get_foreground_color (theme_node, &color);  clutter_text_set_color (CLUTTER_TEXT (priv->entry), &color);  if (st_theme_node_lookup_length (theme_node, "caret-size", TRUE, &size))    clutter_text_set_cursor_size (CLUTTER_TEXT (priv->entry), (int)(.5 + size));  if (st_theme_node_lookup_color (theme_node, "caret-color", TRUE, &color))    clutter_text_set_cursor_color (CLUTTER_TEXT (priv->entry), &color);  if (st_theme_node_lookup_color (theme_node, "selection-background-color", TRUE, &color))    clutter_text_set_selection_color (CLUTTER_TEXT (priv->entry), &color);  if (st_theme_node_lookup_color (theme_node, "selected-color", TRUE, &color))    clutter_text_set_selected_text_color (CLUTTER_TEXT (priv->entry), &color);  font = st_theme_node_get_font (theme_node);  font_string = pango_font_description_to_string (font);  clutter_text_set_font_name (CLUTTER_TEXT (priv->entry), font_string);  g_free (font_string);  ST_WIDGET_CLASS (st_entry_parent_class)->style_changed (self);}

static voidshell_slicer_get_preferred_height (ClutterActor *self,                                   gfloat        for_width,                                   gfloat       *min_height_p,                                   gfloat       *natural_height_p){  ClutterActor *child = st_bin_get_child (ST_BIN (self));  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));  st_theme_node_adjust_for_width (theme_node, &for_width);  if (min_height_p)    *min_height_p = 0;  if (child == NULL)    {      if (natural_height_p)        *natural_height_p = 0;    }  else    {      _st_actor_get_preferred_height (child, for_width, FALSE,                                      NULL,                                      natural_height_p);    }  st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);}

static voidst_widget_allocate (ClutterActor          *actor,                    const ClutterActorBox *box,                    ClutterAllocationFlags flags){  StWidget *self = ST_WIDGET (actor);  StWidgetPrivate *priv = self->priv;  StThemeNode *theme_node;  ClutterActorClass *klass;  ClutterGeometry area;  ClutterVertex in_v, out_v;  theme_node = st_widget_get_theme_node (self);  klass = CLUTTER_ACTOR_CLASS (st_widget_parent_class);  klass->allocate (actor, box, flags);  /* update tooltip position */  if (priv->tooltip)    {      in_v.x = in_v.y = in_v.z = 0;      clutter_actor_apply_transform_to_point (actor, &in_v, &out_v);      area.x = out_v.x;      area.y = out_v.y;      in_v.x = box->x2 - box->x1;      in_v.y = box->y2 - box->y1;      clutter_actor_apply_transform_to_point (actor, &in_v, &out_v);      area.width = out_v.x - area.x;      area.height = out_v.y - area.y;      st_tooltip_set_tip_area (priv->tooltip, &area);    }}

static voidst_box_layout_get_preferred_height (ClutterActor *actor,                                    gfloat        for_width,                                    gfloat       *min_height_p,                                    gfloat       *natural_height_p){  StBoxLayout *self = ST_BOX_LAYOUT (actor);  StBoxLayoutPrivate *priv = self->priv;  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));  st_theme_node_adjust_for_width (theme_node, &for_width);  if (priv->hadjustment)    {      /* If we're scrolled, the parent calls us with the width that       * we'll actually get, which can be smaller than the minimum       * width that we give our contents.       */      gfloat min_width;      get_content_preferred_width (self, -1, &min_width, NULL);      for_width = MAX (for_width, min_width);    }  get_content_preferred_height (self, for_width,                                min_height_p, natural_height_p);  st_theme_node_adjust_preferred_height (theme_node,                                         min_height_p, natural_height_p);}

static voidst_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));  st_theme_node_adjust_for_width (theme_node, &for_width);  if (min_height_p)    *min_height_p = 0;  if (natural_height_p)    *natural_height_p = 0;  if (priv->vertical)    {      gfloat tmin_height_p, tnatural_height_p;      #define ADD_TO_HEIGHT(actor) /        _st_actor_get_preferred_height (actor, for_width, FALSE, /                                        &tmin_height_p, &tnatural_height_p); /        if (min_height_p) /          *min_height_p += tmin_height_p; /        if (natural_height_p) /          *natural_height_p += tnatural_height_p;      ADD_TO_HEIGHT (priv->bw_stepper);      ADD_TO_HEIGHT (priv->fw_stepper);      ADD_TO_HEIGHT (priv->trough);      ADD_TO_HEIGHT (priv->handle);      #undef ADD_TO_HEIGHT    }  else    {      gfloat tmin_height_p, tnatural_height_p;      #define ADJUST_HEIGHT_IF_LARGER(actor) /        _st_actor_get_preferred_height (actor, for_width, FALSE, /                                        &tmin_height_p, &tnatural_height_p); /        if (min_height_p && tmin_height_p > *min_height_p) /          *min_height_p = tmin_height_p; /        if (natural_height_p && tnatural_height_p > *natural_height_p) /          *natural_height_p = tnatural_height_p;      ADJUST_HEIGHT_IF_LARGER (priv->bw_stepper);      ADJUST_HEIGHT_IF_LARGER (priv->fw_stepper);      ADJUST_HEIGHT_IF_LARGER (priv->trough);      ADJUST_HEIGHT_IF_LARGER (priv->handle);      #undef ADJUST_HEIGHT_IF_LARGER    }  st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);}

static voidst_box_layout_paint (ClutterActor *actor){  StBoxLayout *self = ST_BOX_LAYOUT (actor);  StBoxLayoutPrivate *priv = self->priv;  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));  GList *l, *children;  gdouble x, y;  ClutterActorBox allocation_box;  ClutterActorBox content_box;  get_border_paint_offsets (self, &x, &y);  if (x != 0 || y != 0)    {      cogl_push_matrix ();      cogl_translate ((int)x, (int)y, 0);    }  CLUTTER_ACTOR_CLASS (st_box_layout_parent_class)->paint (actor);  if (x != 0 || y != 0)    {      cogl_pop_matrix ();    }  children = st_container_get_children_list (ST_CONTAINER (actor));  if (children == NULL)    return;  clutter_actor_get_allocation_box (actor, &allocation_box);  st_theme_node_get_content_box (theme_node, &allocation_box, &content_box);  content_box.x1 += x;  content_box.y1 += y;  content_box.x2 += x;  content_box.y2 += y;  /* The content area forms the viewport into the scrolled contents, while   * the borders and background stay in place; after drawing the borders and   * background, we clip to the content area */  if (priv->hadjustment || priv->vadjustment)    cogl_clip_push_rectangle ((int)content_box.x1,                              (int)content_box.y1,                              (int)content_box.x2,                              (int)content_box.y2);  for (l = children; l; l = g_list_next (l))    {      ClutterActor *child = (ClutterActor*) l->data;      if (CLUTTER_ACTOR_IS_VISIBLE (child))        clutter_actor_paint (child);    }  if (priv->hadjustment || priv->vadjustment)    cogl_clip_pop ();}

static voidst_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));  ClutterLayoutManager *layout = clutter_actor_get_layout_manager (actor);  ClutterActorBox content_box;  gfloat avail_width, avail_height, min_width, natural_width, min_height, natural_height;  CLUTTER_ACTOR_CLASS (st_box_layout_parent_class)->allocate (actor, box, flags);  st_theme_node_get_content_box (theme_node, box, &content_box);  clutter_actor_box_get_size (&content_box, &avail_width, &avail_height);  clutter_layout_manager_get_preferred_width (layout, CLUTTER_CONTAINER (actor),                                              avail_height,                                              &min_width, &natural_width);  clutter_layout_manager_get_preferred_height (layout, CLUTTER_CONTAINER (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);    }}

static voidst_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 voidst_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 gbooleanshell_generic_container_get_paint_volume (ClutterActor *self,                                          ClutterPaintVolume *volume){  ClutterActorBox paint_box, alloc_box;  StThemeNode *theme_node;  ClutterVertex origin;  /* Setting the paint volume does not make sense when we don't have any allocation */  if (!clutter_actor_has_allocation (self))    return FALSE;  theme_node = st_widget_get_theme_node (ST_WIDGET (self));  clutter_actor_get_allocation_box (self, &alloc_box);  st_theme_node_get_paint_box (theme_node, &alloc_box, &paint_box);  origin.x = paint_box.x1 - alloc_box.x1;  origin.y = paint_box.y1 - alloc_box.y1;  origin.z = 0.0f;  clutter_paint_volume_set_origin (volume, &origin);  clutter_paint_volume_set_width (volume, paint_box.x2 - paint_box.x1);  clutter_paint_volume_set_height (volume, paint_box.y2 - paint_box.y1);  if (!clutter_actor_get_clip_to_allocation (self))    {      ClutterActor *child;      /* Based on ClutterGroup/ClutterBox; include the children's       * paint volumes, since they may paint outside our allocation.       */      for (child = clutter_actor_get_first_child (self);           child != NULL;           child = clutter_actor_get_next_sibling (child))        {          const ClutterPaintVolume *child_volume;          if (!CLUTTER_ACTOR_IS_VISIBLE (child))            continue;          if (shell_generic_container_get_skip_paint (SHELL_GENERIC_CONTAINER  (self), child))            continue;          child_volume = clutter_actor_get_transformed_paint_volume (child, self);          if (!child_volume)            return FALSE;          clutter_paint_volume_union (volume, child_volume);        }    }  return TRUE;}

static voidst_box_layout_paint (ClutterActor *actor){  StBoxLayout *self = ST_BOX_LAYOUT (actor);  StBoxLayoutPrivate *priv = self->priv;  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));  gdouble x, y;  ClutterActorBox allocation_box;  ClutterActorBox content_box;  ClutterActor *child;  get_border_paint_offsets (self, &x, &y);  if (x != 0 || y != 0)    {      cogl_push_matrix ();      cogl_translate ((int)x, (int)y, 0);    }  st_widget_paint_background (ST_WIDGET (actor));  if (x != 0 || y != 0)    {      cogl_pop_matrix ();    }  if (clutter_actor_get_n_children (actor) == 0)    return;  clutter_actor_get_allocation_box (actor, &allocation_box);  st_theme_node_get_content_box (theme_node, &allocation_box, &content_box);  content_box.x1 += x;  content_box.y1 += y;  content_box.x2 += x;  content_box.y2 += y;  /* The content area forms the viewport into the scrolled contents, while   * the borders and background stay in place; after drawing the borders and   * background, we clip to the content area */  if (priv->hadjustment || priv->vadjustment)    cogl_clip_push_rectangle ((int)content_box.x1,                              (int)content_box.y1,                              (int)content_box.x2,                              (int)content_box.y2);  for (child = clutter_actor_get_first_child (actor);       child != NULL;       child = clutter_actor_get_next_sibling (child))    clutter_actor_paint (child);  if (priv->hadjustment || priv->vadjustment)    cogl_clip_pop ();}

static voidst_widget_paint (ClutterActor *actor){  StWidget *self = ST_WIDGET (actor);  StThemeNode *theme_node;  ClutterActorBox allocation;  theme_node = st_widget_get_theme_node (self);  clutter_actor_get_allocation_box (actor, &allocation);  st_theme_node_paint (theme_node, &allocation, clutter_actor_get_paint_opacity (actor));}

static voidst_button_update_label_style (StButton *button){  ClutterActor *label;  label = st_bin_get_child (ST_BIN (button));  /* check the child is really a label */  if (!CLUTTER_IS_TEXT (label))    return;  _st_set_text_from_style (CLUTTER_TEXT (label), st_widget_get_theme_node (ST_WIDGET (button)));}

static voidst_widget_recompute_style (StWidget    *widget,                           StThemeNode *old_theme_node){  StThemeNode *new_theme_node = st_widget_get_theme_node (widget);  if (!old_theme_node ||      !st_theme_node_geometry_equal (old_theme_node, new_theme_node))    clutter_actor_queue_relayout ((ClutterActor *) widget);  g_signal_emit (widget, signals[STYLE_CHANGED], 0);  widget->priv->is_style_dirty = FALSE;}

static voidst_box_layout_pick (ClutterActor       *actor,                    const ClutterColor *color){  StBoxLayout *self = ST_BOX_LAYOUT (actor);  StBoxLayoutPrivate *priv = self->priv;  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));  gdouble x, y;  ClutterActorBox allocation_box;  ClutterActorBox content_box;  ClutterActor *child;  get_border_paint_offsets (self, &x, &y);  if (x != 0 || y != 0)    {      cogl_push_matrix ();      cogl_translate ((int)x, (int)y, 0);    }  CLUTTER_ACTOR_CLASS (st_box_layout_parent_class)->pick (actor, color);  if (x != 0 || y != 0)    {      cogl_pop_matrix ();    }  if (clutter_actor_get_n_children (actor) == 0)    return;  clutter_actor_get_allocation_box (actor, &allocation_box);  st_theme_node_get_content_box (theme_node, &allocation_box, &content_box);  content_box.x1 += x;  content_box.y1 += y;  content_box.x2 += x;  content_box.y2 += y;  if (priv->hadjustment || priv->vadjustment)    cogl_clip_push_rectangle ((int)content_box.x1,                              (int)content_box.y1,                              (int)content_box.x2,                              (int)content_box.y2);  for (child = clutter_actor_get_first_child (actor);       child != NULL;       child = clutter_actor_get_next_sibling (child))    clutter_actor_paint (child);  if (priv->hadjustment || priv->vadjustment)    cogl_clip_pop ();}

static voidsagarmatha_stack_get_preferred_height (ClutterActor *actor,                                  gfloat for_width,                                  gfloat *min_height_p,                                  gfloat *natural_height_p){  SagarmathaStack *stack = SAGARMATHA_STACK (actor);  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));  gboolean first = TRUE;  float min = 0, natural = 0;  GList *children;  GList *iter;  st_theme_node_adjust_for_width (theme_node, &for_width);  children = st_container_get_children_list (ST_CONTAINER (stack));  for (iter = children; iter; iter = iter->next)    {      ClutterActor *child = iter->data;      float child_min, child_natural;      clutter_actor_get_preferred_height (child,                                          for_width,                                          &child_min,                                          &child_natural);      if (first)        {          first = FALSE;          min = child_min;          natural = child_natural;        }      else        {          if (child_min > min)            min = child_min;          if (child_natural > natural)            natural = child_natural;        }    }  if (min_height_p)    *min_height_p = min;  if (natural_height_p)    *natural_height_p = natural;  st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);}

static voidst_box_layout_style_changed (StWidget *self){  StThemeNode *theme_node = st_widget_get_theme_node (self);  ClutterBoxLayout *layout;  double spacing;  layout = CLUTTER_BOX_LAYOUT (clutter_actor_get_layout_manager (CLUTTER_ACTOR (self)));  spacing = st_theme_node_get_length (theme_node, "spacing");  clutter_box_layout_set_spacing (layout, (int)(spacing + 0.5));  ST_WIDGET_CLASS (st_box_layout_parent_class)->style_changed (self);}

static voidst_table_get_preferred_width (ClutterActor *self,                              gfloat        for_height,                              gfloat       *min_width_p,                              gfloat       *natural_width_p){  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;  DimensionData *columns;  if (priv->n_cols < 1)    {      *min_width_p = 0;      *natural_width_p = 0;      return;    }  /* use min_widths to help allocation of height-for-width widgets */  st_table_calculate_dimensions (ST_TABLE (self), -1, for_height);  columns = &g_array_index (priv->columns, DimensionData, 0);  /* start off with row spacing */  total_min_width = (priv->visible_cols - 1) * (float)(priv->col_spacing);  total_pref_width = total_min_width;  for (i = 0; i < priv->n_cols; i++)    {      total_min_width += columns[i].min_size;      total_pref_width += columns[i].pref_size;    }  /* 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 voidst_box_layout_style_changed (StWidget *self){  StBoxLayoutPrivate *priv = ST_BOX_LAYOUT (self)->priv;  StThemeNode *theme_node = st_widget_get_theme_node (self);  int old_spacing = priv->spacing;  double spacing;  spacing = st_theme_node_get_length (theme_node, "spacing");  priv->spacing = (int)(spacing + 0.5);  if (priv->spacing != old_spacing)    clutter_actor_queue_relayout (CLUTTER_ACTOR (self));  ST_WIDGET_CLASS (st_box_layout_parent_class)->style_changed (self);}

static voidst_scroll_view_style_changed (StWidget *widget){  StScrollView *self = ST_SCROLL_VIEW (widget);  StScrollViewPrivate *priv = self->priv;  StThemeNode *theme_node = st_widget_get_theme_node (widget);  gdouble fade_offset = st_theme_node_get_length (theme_node, "-st-vfade-offset");  st_scroll_view_update_vfade_effect (self, fade_offset);  st_widget_style_changed (ST_WIDGET (priv->hscroll));  st_widget_style_changed (ST_WIDGET (priv->vscroll));  ST_WIDGET_CLASS (st_scroll_view_parent_class)->style_changed (widget);}

static voidshell_stack_get_preferred_width (ClutterActor *actor,                                 gfloat for_height,                                 gfloat *min_width_p,                                 gfloat *natural_width_p){  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));  gboolean first = TRUE;  float min = 0, natural = 0;  ClutterActor *child;  st_theme_node_adjust_for_height (theme_node, &for_height);  for (child = clutter_actor_get_first_child (actor);       child != NULL;       child = clutter_actor_get_next_sibling (child))    {      float child_min, child_natural;      clutter_actor_get_preferred_width (child,                                         for_height,                                         &child_min,                                         &child_natural);      if (first)        {          first = FALSE;          min = child_min;          natural = child_natural;        }      else        {          if (child_min > min)            min = child_min;          if (child_natural > natural)            natural = child_natural;        }    }  if (min_width_p)    *min_width_p = min;  if (natural_width_p)    *natural_width_p = natural;  st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);}

static voidcinnamon_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 voidst_box_layout_get_preferred_width (ClutterActor *actor,                                   gfloat        for_height,                                   gfloat       *min_width_p,                                   gfloat       *natural_width_p){  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));  st_theme_node_adjust_for_height (theme_node, &for_height);  get_content_preferred_width (ST_BOX_LAYOUT (actor), for_height,                               min_width_p, natural_width_p);  st_theme_node_adjust_preferred_width (theme_node,                                        min_width_p, natural_width_p);}

static voidst_icon_get_preferred_width (ClutterActor *actor,                             gfloat        for_height,                             gfloat       *min_width_p,                             gfloat       *nat_width_p){  StIconPrivate *priv = ST_ICON (actor)->priv;  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));  if (min_width_p)    *min_width_p = priv->icon_size;  if (nat_width_p)    *nat_width_p = priv->icon_size;  st_theme_node_adjust_preferred_width (theme_node, min_width_p, nat_width_p);}

static voidst_widget_get_preferred_height (ClutterActor *self,                                gfloat        for_width,                                gfloat       *min_height_p,                                gfloat       *natural_height_p){  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));  /* See st_widget_get_preferred_width() */  if (min_height_p)    *min_height_p = 0;  if (natural_height_p)    *natural_height_p = 0;  st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);}

static gbooleanst_box_layout_get_paint_volume (ClutterActor       *actor,                                ClutterPaintVolume *volume){  StBoxLayout *self = ST_BOX_LAYOUT (actor);  gdouble x, y;  StBoxLayoutPrivate *priv = self->priv;  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));  ClutterActorBox allocation_box;  ClutterActorBox content_box;  ClutterVertex origin;  /* When have an adjustment we are clipped to the content box, so base   * our paint volume on that. */  if (priv->hadjustment || priv->vadjustment)    {      clutter_actor_get_allocation_box (actor, &allocation_box);      st_theme_node_get_content_box (theme_node, &allocation_box, &content_box);      origin.x = content_box.x1 - allocation_box.x1;      origin.y = content_box.y1 - allocation_box.y2;      origin.z = 0.f;      clutter_paint_volume_set_width (volume, content_box.x2 - content_box.x1);      clutter_paint_volume_set_height (volume, content_box.y2 - content_box.y1);    }  else if (!CLUTTER_ACTOR_CLASS (st_box_layout_parent_class)->get_paint_volume (actor, volume))    return FALSE;  /* When scrolled, st_box_layout_apply_transform() includes the scroll offset   * and affects paint volumes. This is right for our children, but our paint volume   * is determined by our allocation and borders and doesn't scroll, so we need   * to reverse-compensate here, the same as we do when painting.   */  get_border_paint_offsets (self, &x, &y);  if (x != 0 || y != 0)    {      clutter_paint_volume_get_origin (volume, &origin);      origin.x += x;      origin.y += y;      clutter_paint_volume_set_origin (volume, &origin);    }  return TRUE;}