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

static ClutterActor *mex_menu_item_new (MexMenu *self, MxAction *action, MexMenuActionType type){  ClutterActor *button, *layout, *icon, *vbox, *label, *arrow = NULL;  button = mx_button_new ();  mx_button_set_is_toggle (MX_BUTTON (button), TRUE);  mx_stylable_set_style_class (MX_STYLABLE (button), "Item");  layout = mx_box_layout_new ();  mx_bin_set_child (MX_BIN (button), layout);  mx_bin_set_fill (MX_BIN (button), TRUE, FALSE);  if (type == MEX_MENU_LEFT)    {      arrow = mx_icon_new ();      mx_stylable_set_style_class (MX_STYLABLE (arrow), "Left");      clutter_container_add_actor (CLUTTER_CONTAINER (layout), arrow);    }  vbox = mx_box_layout_new ();  mx_box_layout_set_orientation (MX_BOX_LAYOUT (vbox), MX_ORIENTATION_VERTICAL);  label = mx_label_new ();  mx_label_set_fade_out (MX_LABEL (label), TRUE);  mx_stylable_set_style_class (MX_STYLABLE (label), "Action");  g_object_bind_property (action, "display-name", label, "text",                          G_BINDING_SYNC_CREATE);  clutter_container_add_actor (CLUTTER_CONTAINER (vbox), label);  label = mx_label_new ();  mx_label_set_fade_out (MX_LABEL (label), TRUE);  mx_stylable_set_style_class (MX_STYLABLE (label), "Detail");  clutter_container_add_actor (CLUTTER_CONTAINER (vbox), label);  clutter_actor_hide (label);  g_object_set_data (G_OBJECT (button), "detail-label", label);  clutter_container_add_actor (CLUTTER_CONTAINER (layout), vbox);  clutter_container_child_set (CLUTTER_CONTAINER (layout), vbox,                               "expand", TRUE,                               "x-fill", FALSE,                               "x-align", MX_ALIGN_START,                               "y-fill", FALSE,                               NULL);  icon = mx_icon_new ();  g_object_bind_property (action, "icon", icon, "icon-name",                          G_BINDING_SYNC_CREATE);  clutter_container_add_actor (CLUTTER_CONTAINER (layout), icon);  if (type == MEX_MENU_RIGHT)    {      arrow = mx_icon_new ();      mx_stylable_set_style_class (MX_STYLABLE (arrow), "Right");      clutter_container_add_actor (CLUTTER_CONTAINER (layout), arrow);    }  else if (type == MEX_MENU_TOGGLE)    {      ClutterActor *toggle = mx_icon_new ();      mx_stylable_set_style_class (MX_STYLABLE (toggle), "Toggle");      clutter_container_add_actor (CLUTTER_CONTAINER (layout), toggle);      g_object_set_data (G_OBJECT (button), "toggle-icon", toggle);    }  if (arrow)    clutter_container_child_set (CLUTTER_CONTAINER (layout),                                 arrow,                                 "expand", FALSE,                                 "y-align", MX_ALIGN_MIDDLE,                                 "y-fill", FALSE,                                 NULL);  g_signal_connect (button, "clicked",                    G_CALLBACK (mex_menu_item_clicked_cb), action);  g_object_weak_ref (G_OBJECT (button),                     (GWeakNotify)mex_menu_item_destroyed_cb,                     self);  /* Set the item qdata on the button to mark that we created it */  g_object_set_qdata (G_OBJECT (button), mex_menu_item_quark,                      GINT_TO_POINTER (TRUE));  return button;}

static voidst_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);}

voidtest_cogl_vertex_buffer_contiguous (TestUtilsGTestFixture *fixture,		                    void *data){  TestState state;  ClutterActor *stage;  ClutterColor stage_clr = {0x0, 0x0, 0x0, 0xff};  ClutterActor *group;  unsigned int idle_source;  guchar tex_data[] = {    0xff, 0x00, 0x00, 0xff,    0xff, 0x00, 0x00, 0xff,    0x00, 0xff, 0x00, 0xff,    0x00, 0xff, 0x00, 0xff  };  stage = clutter_stage_get_default ();  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_clr);  clutter_actor_get_geometry (stage, &state.stage_geom);  group = clutter_group_new ();  clutter_actor_set_size (group,			  state.stage_geom.width,			  state.stage_geom.height);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), group);  /* We force continuous redrawing incase someone comments out the   * clutter_main_quit and wants visual feedback for the test since we   * wont be doing anything else that will trigger redrawing. */  idle_source = g_idle_add (queue_redraw, stage);  g_signal_connect (group, "paint", G_CALLBACK (on_paint), &state);  state.texture = cogl_texture_new_from_data (2, 2,                                              COGL_TEXTURE_NO_SLICING,                                              COGL_PIXEL_FORMAT_RGBA_8888,                                              COGL_PIXEL_FORMAT_ANY,                                              0, /* auto calc row stride */                                              tex_data);  state.material = cogl_material_new ();  cogl_material_set_color4ub (state.material, 0x00, 0xff, 0x00, 0xff);  cogl_material_set_layer (state.material, 0, state.texture);  {    GLfloat triangle_verts[3][2] =      {	{0.0,	0.0},	{100.0, 100.0},	{0.0,	100.0}      };    GLbyte triangle_colors[3][4] =      {	{0x00, 0x00, 0xff, 0xff}, /* blue */	{0x00, 0x00, 0xff, 0x00}, /* transparent blue */	{0x00, 0x00, 0xff, 0x00}  /* transparent blue */      };    GLfloat triangle_tex_coords[3][2] =      {        {0.0, 0.0},        {1.0, 1.0},        {0.0, 1.0}      };    state.buffer = cogl_vertex_buffer_new (3 /* n vertices */);    cogl_vertex_buffer_add (state.buffer,			    "gl_Vertex",			    2, /* n components */			    GL_FLOAT,			    FALSE, /* normalized */			    0, /* stride */			    triangle_verts);    cogl_vertex_buffer_add (state.buffer,			    "gl_Color::blue",			    4, /* n components */			    GL_UNSIGNED_BYTE,			    FALSE, /* normalized */			    0, /* stride */			    triangle_colors);    cogl_vertex_buffer_add (state.buffer,			    "gl_MultiTexCoord0",			    2, /* n components */			    GL_FLOAT,			    FALSE, /* normalized */			    0, /* stride */			    triangle_tex_coords);    cogl_vertex_buffer_submit (state.buffer);  }  clutter_actor_show_all (stage);  clutter_main ();  cogl_handle_unref (state.buffer);  cogl_handle_unref (state.material);  cogl_handle_unref (state.texture);  g_source_remove (idle_source);//.........这里部分代码省略.........

static voidst_table_homogeneous_allocate (ClutterActor          *self,                               const ClutterActorBox *content_box,                               gboolean               flags){  gfloat col_width, row_height;  gint row_spacing, col_spacing;  StTablePrivate *priv = ST_TABLE (self)->priv;  gboolean ltr = clutter_actor_get_text_direction (self) == CLUTTER_TEXT_DIRECTION_LTR;  ClutterActor *child;  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);  for (child = clutter_actor_get_first_child (self);       child != NULL;       child = clutter_actor_get_next_sibling (child))    {      gint row, col, row_span, col_span;      StTableChild *meta;      ClutterActorBox childbox;      gdouble x_align_f, y_align_f;      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;      _st_get_align_factors (meta->x_align, meta->y_align,                             &x_align_f, &y_align_f);      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));      clutter_actor_allocate_align_fill (child, &childbox,                                         x_align_f, y_align_f,                                         meta->x_fill, meta->y_fill,                                         flags);    }}

static gint *st_table_calculate_row_heights (StTable *table,                                gint     for_height,                                gint   * col_widths){  StTablePrivate *priv = ST_TABLE (table)->priv;  gint *is_expand_row, *min_heights, *pref_heights, *row_heights, extra_row_height;  gint i, total_min_height;  gint expanded_rows = 0;  gint n_expanded_rows = 0;  ClutterActor *child;  g_array_set_size (priv->row_heights, 0);  g_array_set_size (priv->row_heights, priv->n_rows);  row_heights = (gboolean *) priv->row_heights->data;  g_array_set_size (priv->is_expand_row, 0);  g_array_set_size (priv->is_expand_row, priv->n_rows);  is_expand_row = (gboolean *) priv->is_expand_row->data;  g_array_set_size (priv->min_heights, 0);  g_array_set_size (priv->min_heights, priv->n_rows);  min_heights = (gboolean *) priv->min_heights->data;  g_array_set_size (priv->pref_heights, 0);  g_array_set_size (priv->pref_heights, priv->n_rows);  pref_heights = (gboolean *) priv->pref_heights->data;  for (child = clutter_actor_get_first_child (CLUTTER_ACTOR (table));       child != NULL;       child = clutter_actor_get_next_sibling (child))    {      gint row, col, cell_width;      gfloat h_min, h_pref;      gboolean y_expand;      StTableChild *meta;      gint col_span, row_span;      meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);      if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))        continue;      /* get child properties */      col = meta->col;      row = meta->row;      y_expand = meta->y_expand;      col_span = meta->col_span;      row_span = meta->row_span;      if (y_expand)        is_expand_row[row] = TRUE;      /* calculate the cell width by including any spanned columns */      cell_width = 0;      for (i = 0; i < col_span && col + i < priv->n_cols; i++)        cell_width += (float)(col_widths[col + i]);      if (!meta->x_fill)        {          gfloat width;          _st_actor_get_preferred_width (child, -1, meta->y_fill, NULL, &width);          cell_width = MIN (cell_width, width);        }      _st_actor_get_preferred_height (child, cell_width, meta->x_fill,                                      &h_min, &h_pref);      if (row_span == 1 && h_pref > pref_heights[row])        {          pref_heights[row] = (int)(h_pref);        }      if (row_span == 1 && h_min > min_heights[row])        {          min_heights[row] = (int)(h_min);        }    }  total_min_height = 0; // priv->row_spacing * (priv->n_rows - 1);  for (i = 0; i < priv->n_rows; i++)    total_min_height += pref_heights[i];  /* calculate the remaining space and distribute it evenly onto all rows/cols   * with the x/y expand property set. */  for (i = 0; i < priv->n_rows; i++)    if (is_expand_row[i])      {        expanded_rows += pref_heights[i];        n_expanded_rows++;      }  /* extra row height = for height - row spacings - total_min_height */  for_height -= (priv->row_spacing * (priv->n_rows - 1));  extra_row_height = for_height - total_min_height;  if (extra_row_height < 0)    {      gint *skip = g_slice_alloc0 (sizeof (gint) * priv->n_rows);      gint total_shrink_height;//.........这里部分代码省略.........

intmain (int     argc,      char  **argv){  bool standalone = false;  char const *geometry = NULL;  int dpi = 0;  GOptionEntry _options[] = {    { "standalone", 's', 0, G_OPTION_ARG_NONE, &standalone,      "Run as standalone app (for testing purpose)", NULL },    { "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry,      "Window geometry in standalone mode", NULL },#if CLUTTER_CHECK_VERSION(1, 3, 0)    { "clutter-font-dpi", 'd', 0, G_OPTION_ARG_INT, &dpi,      "Set clutter font resolution to <dpi>", "<dpi>" },#endif    { NULL }  };  ClutterActor     *shell;  GOptionContext   *context;  ClutterInitError  clutter_error;  GError           *error = NULL;  setlocale (LC_ALL, "");  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");  textdomain (GETTEXT_PACKAGE);  context = g_option_context_new ("- Dawati devices panel");  g_option_context_add_main_entries (context, _options, GETTEXT_PACKAGE);  g_option_context_add_group (context, clutter_get_option_group_without_init ());  if (!g_option_context_parse (context, &argc, &argv, &error))  {    g_critical ("%s %s", G_STRLOC, error->message);    g_critical ("Starting in standalone mode.");    g_clear_error (&error);    standalone = true;  }  g_option_context_free (context);  clutter_error = clutter_init (&argc, &argv);  if (clutter_error != CLUTTER_INIT_SUCCESS)    {      g_critical ("Unable to initialise clutter");      return EXIT_FAILURE;    }  notify_init (_("Dawati Devices Panel"));  /* Just for icon theme, no widgets. */  gtk_init (&argc, &argv);  if (dpi)    {#if CLUTTER_CHECK_VERSION(1, 3, 0)      ClutterSettings *settings = clutter_settings_get_default ();      g_object_set (settings, "font-dpi", dpi * 1000, NULL);#endif    }  /* Load base styling for default font size */  mpl_panel_clutter_load_base_style ();  mx_texture_cache_load_cache (mx_texture_cache_get_default (),                               PKGDATADIR "/mx.cache");  mx_style_load_from_file (mx_style_get_default (),                           THEMEDIR "/panel.css", NULL);  if (standalone)  {    ClutterActor *stage = clutter_stage_get_default ();    if (geometry)    {      int x, y;      unsigned int width, height;      XParseGeometry (geometry, &x, &y, &width, &height);      clutter_actor_set_size (stage, width, height);    } else    {      clutter_actor_set_size (stage, MPD_SHELL_WIDTH, MPD_SHELL_HEIGHT);    }    shell = mpd_shell_new ();    g_signal_connect (shell, "request-hide",                      G_CALLBACK (_shell_request_hide_cb), NULL);    g_signal_connect (stage, "notify::width",                      G_CALLBACK (_stage_width_notify_cb), shell);    g_signal_connect (stage, "notify::height",                      G_CALLBACK (_stage_height_notify_cb), shell);    clutter_container_add_actor (CLUTTER_CONTAINER (stage), shell);    clutter_actor_show_all (stage);  } else {    MplPanelClient *panel = mpd_panel_new ("devices",                                           _("devices"),//.........这里部分代码省略.........

voidscene_prismatic_joint (Scene *scene){  ClutterActor     *ground;  ClutterActor     *group;  ClutterActor     *prev_hand  = NULL;  ClutterActor     *first_hand = NULL;  ClutterActor     *stage;  stage = clutter_stage_get_default ();  first_hand = ground = clutter_rectangle_new ();  clutter_actor_set_size (ground, 500, 120);  group = clutter_box2d_new ();  clutter_group_add (CLUTTER_GROUP (stage), group);  clutter_group_add (CLUTTER_GROUP (group), ground);  clutter_actor_set_position (ground, clutter_actor_get_width (                                ground) * -0.3, 568);                             /*                                                                                    this                                                                                    is                                                                                    wrong                                                                                    */  add_cage (group, TRUE);  ground = clutter_rectangle_new ();  clutter_actor_set_size (ground, 256, 3);  clutter_actor_set_position (ground, -100, 310);  clutter_actor_set_rotation (ground, CLUTTER_Z_AXIS, 30, 128, 16, 0);  clutter_group_add (CLUTTER_GROUP (group), ground);  clutter_container_child_set (CLUTTER_CONTAINER (group), ground,                               "mode", CLUTTER_BOX2D_STATIC, NULL);  ground = clutter_rectangle_new ();  clutter_actor_set_size (ground, 256, 3);  clutter_actor_set_position (ground, 200, 200);  clutter_actor_set_rotation (ground, CLUTTER_Z_AXIS, -30, 0, 0, 0);  clutter_group_add (CLUTTER_GROUP (group), ground);  clutter_container_child_set (CLUTTER_CONTAINER (group), ground,                               "mode", CLUTTER_BOX2D_STATIC, NULL);  /*add_hand (group, 100, 100);*/  prev_hand = add_hand (group, 200, 100);  if(0){    ClutterVertex anchor1 = {  (0),                               (0) };    ClutterVertex anchor2 = {  (0),                               (0) };    ClutterVertex axis = {  (100.0),                            (20.0) };    clutter_box2d_add_prismatic_joint (CLUTTER_BOX2D (group),                                       first_hand, prev_hand,                                       &anchor1, &anchor2,                                       200.0, 220.0, &axis);  }  clutter_actor_set_depth (group, -600);  clutter_actor_set_position (group, 0, -100);  clutter_actor_set_reactive (group, TRUE);  clutter_box2d_set_simulating (CLUTTER_BOX2D (group), simulating);  scene->group = group;}

intmain (int argc, char *argv[]){  GError *error = NULL;  /* UI */  ClutterActor *stage;  ClutterLayoutManager *layout;  ClutterActor *box;  ClutterActor *top, *bottom;  ClutterState *transitions;  clutter_init_with_args (&argc, &argv,                          " - cross-fade", entries,                          NULL,                          NULL);  if (source == NULL || target == NULL)    {      g_print ("Usage: %s -s <source> -t <target> [-d <duration>]/n", argv[0]);      exit (EXIT_FAILURE);    }  clutter_init (&argc, &argv);  stage = clutter_stage_get_default ();  clutter_stage_set_title (CLUTTER_STAGE (stage), "cross-fade");  clutter_actor_set_size (stage, 400, 300);  clutter_actor_show (stage);  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,                                   CLUTTER_BIN_ALIGNMENT_CENTER);  box = clutter_box_new (layout);  clutter_actor_set_size (box, 400, 300);  bottom = clutter_texture_new ();  top = clutter_texture_new ();  clutter_container_add_actor (CLUTTER_CONTAINER (box), bottom);  clutter_container_add_actor (CLUTTER_CONTAINER (box), top);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);  /* load the first image into the bottom */  load_image (CLUTTER_TEXTURE (bottom), source);  /* load the second image into the top */  load_image (CLUTTER_TEXTURE (top), target);  /* animations */  transitions = clutter_state_new ();  clutter_state_set (transitions, NULL, "show-bottom",                     top, "opacity", CLUTTER_LINEAR, 0,                     bottom, "opacity", CLUTTER_LINEAR, 255,                     NULL);  clutter_state_set (transitions, NULL, "show-top",                     top, "opacity", CLUTTER_EASE_IN_CUBIC, 255,                     bottom, "opacity", CLUTTER_EASE_IN_CUBIC, 0,                     NULL);  clutter_state_set_duration (transitions, NULL, NULL, duration);  /* make the bottom opaque and top transparent */  clutter_state_warp_to_state (transitions, "show-bottom");  /* on key press, fade in the top texture and fade out the bottom texture */  g_signal_connect (stage,                    "key-press-event",                    G_CALLBACK (start_animation),                    transitions);  clutter_actor_show (stage);  clutter_main ();  g_object_unref (transitions);  if (error != NULL)    g_error_free (error);  return EXIT_SUCCESS;}

//.........这里部分代码省略.........      if (gvalue == NULL)        continue;      user_label = location_key_to_label (skey);      label = gtk_label_new (user_label);      gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);      gtk_table_attach (GTK_TABLE (information->table_location),          label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 10, 0);      gtk_widget_show (label);      if (G_VALUE_TYPE (gvalue) == G_TYPE_DOUBLE)        {          gdouble dvalue;          dvalue = g_value_get_double (gvalue);          svalue = g_strdup_printf ("%f", dvalue);        }      else if (G_VALUE_TYPE (gvalue) == G_TYPE_STRING)        {          svalue = g_value_dup_string (gvalue);        }      else if (G_VALUE_TYPE (gvalue) == G_TYPE_INT64)        {          time_t time_;          time_ = g_value_get_int64 (value);          svalue = empathy_time_to_string_utc (time_, _("%B %e, %Y at %R UTC"));        }      if (svalue != NULL)        {          label = gtk_label_new (svalue);          gtk_table_attach_defaults (GTK_TABLE (information->table_location),              label, 1, 2, row, row + 1);          gtk_misc_set_alignment (GTK_MISC (label), 0, 0);          gtk_widget_show (label);          if (!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP))            gtk_label_set_selectable (GTK_LABEL (label), TRUE);        }      g_free (svalue);      row++;    }#if HAVE_LIBCHAMPLAIN  if (has_position &&      !(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP))    {      /* Cannot be displayed in tooltips until Clutter-Gtk can deal with such       * windows */      display_map = TRUE;    }#endif  if (row > 0)    {      /* We can display some fields */      gtk_widget_show (information->table_location);    }  else if (!display_map)    {      /* Can't display either fields or map */      gtk_widget_hide (information->vbox_location);      return;    }#if HAVE_LIBCHAMPLAIN  if (display_map)    {      ClutterActor *marker;      ChamplainLayer *layer;      information->map_view_embed = gtk_champlain_embed_new ();      information->map_view = gtk_champlain_embed_get_view (          GTK_CHAMPLAIN_EMBED (information->map_view_embed));      gtk_container_add (GTK_CONTAINER (information->viewport_map),          information->map_view_embed);      g_object_set (G_OBJECT (information->map_view),          "show-license", TRUE,          "scroll-mode", CHAMPLAIN_SCROLL_MODE_KINETIC,          "zoom-level", 10,          NULL);      layer = champlain_layer_new ();      champlain_view_add_layer (information->map_view, layer);      marker = champlain_marker_new_with_text (          empathy_contact_get_name (information->contact), NULL, NULL, NULL);      champlain_base_marker_set_position (CHAMPLAIN_BASE_MARKER (marker), lat, lon);      clutter_container_add (CLUTTER_CONTAINER (layer), marker, NULL);      champlain_view_center_on (information->map_view, lat, lon);      gtk_widget_show_all (information->viewport_map);    }#endif    gtk_widget_show (information->vbox_location);}

static void_update_layout (PengeGridView *grid_view){  PengeGridViewPrivate *priv = GET_PRIVATE (grid_view);  gint col = 0;  if (priv->vertical_apps)  {    clutter_container_child_set (CLUTTER_CONTAINER (grid_view),                                 priv->favourite_apps_pane,                                 "column", col,                                 "row", 1,                                 "y-expand", TRUE,                                 "y-fill", FALSE,                                 "y-align", MX_ALIGN_START,                                 "x-align", MX_ALIGN_START,                                 "x-expand", FALSE,                                 "x-fill", FALSE,                                 NULL);    if (priv->show_calendar_pane)    {      col++;      clutter_actor_show (priv->calendar_pane);      clutter_container_child_set (CLUTTER_CONTAINER (grid_view),                                   priv->calendar_pane,                                   "column", col,                                   "x-expand", FALSE,                                   "y-fill", FALSE,                                   "y-align", MX_ALIGN_START,                                   NULL);    } else {      clutter_actor_hide (priv->calendar_pane);    }    if (priv->show_email_pane)    {       clutter_actor_show (priv->email_pane);      clutter_container_child_set (CLUTTER_CONTAINER (grid_view),                                   priv->email_pane,                                   "column", col,                                   "y-expand", TRUE,                                   "y-fill", FALSE,                                   "y-align", MX_ALIGN_END,                                   "x-align", MX_ALIGN_MIDDLE,                                   "x-expand", FALSE,                                   "x-fill", FALSE,                                   NULL);      col++;    } else {      clutter_actor_hide (priv->email_pane);    }    clutter_container_child_set (CLUTTER_CONTAINER (grid_view),                                 priv->div_tex,                                 "row-span", 1,                                 "column", col,                                 "x-expand", FALSE,                                 NULL);    col++;    clutter_container_child_set (CLUTTER_CONTAINER (grid_view),                                 priv->everything_pane,                                 "row-span", 1,                                 "column", col,                                 "x-expand", TRUE,                                 "x-fill", TRUE,                                 "y-expand", TRUE,                                 "y-fill", TRUE,                                 NULL);    if (priv->show_email_pane)    {      clutter_container_child_set (CLUTTER_CONTAINER (grid_view),                                   priv->everything_pane,                                   "row-span", 2,                                   NULL);      clutter_container_child_set (CLUTTER_CONTAINER (grid_view),                                   priv->div_tex,                                   "row-span", 2,                                   NULL);    } else {      clutter_container_child_set (CLUTTER_CONTAINER (grid_view),                                   priv->everything_pane,                                   "row-span", 1,                                   NULL);      clutter_container_child_set (CLUTTER_CONTAINER (grid_view),                                   priv->div_tex,                                   "row-span", 1,                                   NULL);    }    g_object_set (priv->favourite_apps_pane,                  "vertical", TRUE,                  NULL);    if (!priv->show_calendar_pane)//.........这里部分代码省略.........

intmain (int   argc,      char *argv[]){  ClutterActor *stage;  ClutterActor *texture;  ClutterEffect *effect;  ClutterState *transitions;  GError *error = NULL;  gchar *filename;  if (argc < 2)    {      g_print ("Usage: %s <path to image file>/n", argv[0]);      return EXIT_FAILURE;    }  filename = argv[1];  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  stage = clutter_stage_new ();  clutter_actor_set_size (stage, 400, 300);  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  texture = clutter_texture_new ();  clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (texture), TRUE);  clutter_actor_set_width (texture, 400);  clutter_actor_set_reactive (texture, TRUE);  clutter_texture_set_from_file (CLUTTER_TEXTURE (texture),                                 filename,                                 &error);  if (error != NULL)    {      g_critical ("Error loading texture from file %s; error was:/n%s",                  filename,                  error->message);      return EXIT_FAILURE;    }  /* create the page fold effect instance with destination fold angle   * of 180 degrees and starting period of 0 (no folding)   */  effect = cb_page_fold_effect_new (180.0, 0.0);  /* add the effect to the texture actor */  clutter_actor_add_effect (texture, effect);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), texture);  /* animation for the period property of the effect,   * to animate its value between 0.0 and 1.0 and back   */  transitions = clutter_state_new ();  clutter_state_set_duration (transitions, NULL, NULL, 500);  clutter_state_set_duration (transitions,                              "partially-folded",                              "folded",                              375);  clutter_state_set (transitions, NULL, "folded",                     effect, "period", CLUTTER_LINEAR, 1.0,                     NULL);  clutter_state_set (transitions, NULL, "partially-folded",                     effect, "period", CLUTTER_LINEAR, 0.25,                     NULL);  clutter_state_set (transitions, NULL, "unfolded",                     effect, "period", CLUTTER_LINEAR, 0.0,                     NULL);  clutter_state_warp_to_state (transitions, "partially-folded");  g_signal_connect (texture,                    "button-press-event",                    G_CALLBACK (button_pressed_cb),                    transitions);  clutter_actor_show (stage);  clutter_main ();  g_object_unref (transitions);  return EXIT_SUCCESS;}

intmain (int argc, char **argv){  ClutterActor *stage = stage;  ClutterActor *side_box;  ClutterActor *button_box;  ClutterActor *box;  ClutterAnimation *anim;  MashLightSet *light_set;  MxStyle *style;  GError *error = NULL;  Data data;  int i;  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  style = mx_style_get_default ();  if (!mx_style_load_from_file (style, "lights.css",                                &error))    {      g_warning ("Error setting style: %s", error->message);      g_clear_error (&error);    }  stage = clutter_stage_get_default ();  clutter_actor_set_size (stage, 800, 600);  side_box = mx_table_new ();  clutter_actor_set_name (side_box, "side-box");  clutter_container_add_actor (CLUTTER_CONTAINER (stage), side_box);  clutter_actor_set_size (side_box, 300,                          clutter_actor_get_height (stage));  clutter_actor_set_x (side_box,                       clutter_actor_get_width (stage)                       - clutter_actor_get_width (side_box));  button_box = mx_table_new ();  mx_table_add_actor (MX_TABLE (side_box), button_box, 0, 0);  data.notebook = mx_notebook_new ();  mx_table_add_actor (MX_TABLE (side_box), data.notebook, 1, 0);  data.model = mash_model_new_from_file (MASH_DATA_NONE,                                         argc > 1                                         ? argv[1]                                         : "suzanne.ply",                                         &error);  if (data.model == NULL)    {      g_warning ("Error loading model: %s", error->message);      g_clear_error (&error);      return 1;    }  light_set = mash_light_set_new ();  box = clutter_box_new (clutter_fixed_layout_new ());  clutter_actor_set_size (data.model, 400, 400);  clutter_actor_set_position (data.model, 50.0, 100.0);  clutter_container_add_actor (CLUTTER_CONTAINER (box), data.model);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);  g_signal_connect_swapped (box, "paint",                            G_CALLBACK (cogl_set_depth_test_enabled),                            GINT_TO_POINTER (TRUE));  g_signal_connect_data (box, "paint",                         G_CALLBACK (cogl_set_depth_test_enabled),                         GINT_TO_POINTER (FALSE), NULL,                         G_CONNECT_AFTER | G_CONNECT_SWAPPED);  data.light_marker_material = cogl_material_new ();  {    CoglColor color;    cogl_color_set_from_4ub (&color, 255, 0, 0, 255);    /* Use the layer state to ignore the vertex color from the shader so       that the light marker won't itself be lit */    cogl_material_set_layer_combine_constant (data.light_marker_material, 0,                                              &color);    cogl_material_set_layer_combine (data.light_marker_material, 0,                                     "RGBA = REPLACE(CONSTANT)",                                     NULL);  }  clutter_actor_set_rotation (data.model, CLUTTER_Y_AXIS,                              0.0f,                              clutter_actor_get_width (data.model) / 2.0f,                              0.0f,                              0.0f);  anim = clutter_actor_animate (data.model, CLUTTER_LINEAR, 3000,                                "rotation-angle-y", 360.0f,                                NULL);  clutter_animation_set_loop (anim, TRUE);  for (i = 0; i < N_LIGHTS; i++)    {//.........这里部分代码省略.........

G_MODULE_EXPORT inttest_bin_layout_main (int argc, char *argv[]){  ClutterActor *stage, *box, *rect;  ClutterLayoutManager *layout;  ClutterColor stage_color = { 0xe0, 0xf2, 0xfc, 0xff };  ClutterColor bg_color = { 0xcc, 0xcc, 0xcc, 0x99 };  ClutterColor *color;  clutter_init (&argc, &argv);  stage = clutter_stage_get_default ();  clutter_stage_set_title (CLUTTER_STAGE (stage), "Box test");  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  clutter_actor_set_size (stage, 640, 480);  layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,                                   CLUTTER_BIN_ALIGNMENT_CENTER);  box = clutter_box_new (layout);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);  clutter_actor_set_anchor_point_from_gravity (box, CLUTTER_GRAVITY_CENTER);  clutter_actor_set_position (box, 320, 240);  clutter_actor_set_reactive (box, TRUE);  clutter_actor_set_name (box, "box");  rect = make_background (&bg_color, 200, 200);  /* first method: use clutter_box_pack() */  clutter_box_pack (CLUTTER_BOX (box), rect,                    "x-align", CLUTTER_BIN_ALIGNMENT_FILL,                    "y-align", CLUTTER_BIN_ALIGNMENT_FILL,                    NULL);  clutter_actor_lower_bottom (rect);  clutter_actor_set_name (rect, "background");  {    ClutterActor *tex;    GError *error;    gchar *file;    error = NULL;    file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);    tex = clutter_texture_new_from_file (file, &error);    if (error)      g_error ("Unable to create texture: %s", error->message);    clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (tex), TRUE);    /* second method: use clutter_bin_layout_add() */    clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (layout), tex,                            CLUTTER_BIN_ALIGNMENT_CENTER,                            CLUTTER_BIN_ALIGNMENT_CENTER);    clutter_actor_raise (tex, rect);    clutter_actor_set_width (tex, 175);    clutter_actor_set_name (tex, "texture");    g_free (file);  }  color = clutter_color_new (g_random_int_range (0, 255),                             g_random_int_range (0, 255),                             g_random_int_range (0, 255),                             224);  rect = clutter_rectangle_new_with_color (color);  /* third method: container_add() and set_alignment() */  clutter_container_add_actor (CLUTTER_CONTAINER (box), rect);  clutter_bin_layout_set_alignment (CLUTTER_BIN_LAYOUT (layout), rect,                                    CLUTTER_BIN_ALIGNMENT_END,                                    CLUTTER_BIN_ALIGNMENT_END);  clutter_actor_set_size (rect, 50, 50);  clutter_actor_set_opacity (rect, 0);  clutter_actor_raise_top (rect);  clutter_actor_set_name (rect, "emblem");  g_signal_connect (box,                    "enter-event", G_CALLBACK (on_box_enter),                    rect);  g_signal_connect (box,                    "leave-event", G_CALLBACK (on_box_leave),                    rect);  clutter_actor_show_all (stage);  clutter_main ();  clutter_color_free (color);  return EXIT_SUCCESS;}

static voidmex_media_controls_init (MexMediaControls *self){    ClutterActor *actor;    ClutterScript *script;    GError *err = NULL;    MxAdjustment *adjustment;    ClutterActor *related_box;    gchar *tmp;    MexMediaControlsPrivate *priv = self->priv = MEDIA_CONTROLS_PRIVATE (self);    priv->script = script = clutter_script_new ();    tmp = g_build_filename (mex_get_data_dir (), "json", "media-controls.json",                            NULL);    clutter_script_load_from_file (script, tmp, &err);    g_free (tmp);    if (err)        g_error ("Could not load media controls interface: %s", err->message);    priv->vbox =        (ClutterActor*) clutter_script_get_object (script, "media-controls");    clutter_actor_set_parent (priv->vbox, CLUTTER_ACTOR (self));    /* add shadow to media controls box */    actor = (ClutterActor *) clutter_script_get_object (script,            "media-controls-box");    clutter_actor_add_effect (actor, CLUTTER_EFFECT (mex_shadow_new ()));    /* vertical fade effect */    priv->vertical_effect = mx_fade_effect_new ();    clutter_actor_add_effect (priv->vbox, priv->vertical_effect);    mx_scrollable_get_adjustments (MX_SCROLLABLE (mx_bin_get_child (MX_BIN (priv->vbox))),                                   NULL, &adjustment);    g_signal_connect (adjustment, "changed",                      G_CALLBACK (notify_vertical_changed_cb), self);    g_signal_connect (adjustment, "notify::value",                      G_CALLBACK (notify_vertical_value_cb), self);    /* horizontal fade effect */    priv->horizontal_effect = mx_fade_effect_new ();    related_box = (ClutterActor *) clutter_script_get_object (priv->script,                  "related-box");    clutter_actor_add_effect (related_box, priv->horizontal_effect);    mx_scrollable_get_adjustments (MX_SCROLLABLE (related_box), &adjustment,                                   NULL);    g_signal_connect (adjustment, "changed",                      G_CALLBACK (notify_horizontal_changed_cb), self);    g_signal_connect (adjustment, "notify::value",                      G_CALLBACK (notify_horizontal_value_cb), self);    /* slider setup */    priv->slider = (ClutterActor*) clutter_script_get_object (script, "slider");    g_signal_connect (priv->slider, "notify::value",                      G_CALLBACK (slider_value_changed_cb), self);    g_signal_connect (priv->slider, "captured-event",                      G_CALLBACK (slider_captured_event), self);    priv->play_pause_action =        (MxAction*) clutter_script_get_object (script, "play-pause-action");    priv->stop_action =        (MxAction*) clutter_script_get_object (script, "stop-action");    priv->add_to_queue_action =        (MxAction*) clutter_script_get_object (script, "add-to-queue-action");    priv->queue_button =        (ClutterActor *) clutter_script_get_object (script, "add-to-queue-button");    g_signal_connect (priv->play_pause_action, "activated",                      G_CALLBACK (mex_media_controls_play_cb), self);    g_signal_connect (priv->stop_action, "activated",                      G_CALLBACK (mex_media_controls_stop_cb), self);#if 0    g_signal_connect (priv->add_to_queue_action, "activated",                      G_CALLBACK (mex_media_controls_add_to_queue_cb), self);#endif    /* proxy setup */    priv->proxy_model = MEX_VIEW_MODEL (mex_view_model_new (NULL));    /* FIXME: Set an arbitrary 200-item limit as we can't handle large     *        amounts of actors without massive slow-down.     */    mex_view_model_set_limit (priv->proxy_model, 200);    priv->proxy = mex_content_proxy_new (MEX_MODEL (priv->proxy_model),                                         CLUTTER_CONTAINER (related_box),                                         MEX_TYPE_CONTENT_TILE);    g_signal_connect (priv->proxy, "object-created", G_CALLBACK (tile_created_cb),                      self);    priv->is_disabled = TRUE;}

/** * clutter_box_packv: * @box: a #ClutterBox * @actor: a #ClutterActor * @n_properties: the number of properties to set * @properties: (array length=n_properties) (element-type utf8): a vector *   containing the property names to set * @values: (array length=n_properties): a vector containing the property *   values to set * * Vector-based variant of clutter_box_pack(), intended for language * bindings to use * * Since: 1.2 */voidclutter_box_packv (ClutterBox          *box,                   ClutterActor        *actor,                   guint                n_properties,                   const gchar * const  properties[],                   const GValue        *values){  ClutterContainer *container;  ClutterBoxPrivate *priv;  ClutterLayoutMeta *meta;  GObjectClass *klass;  gint i;  g_return_if_fail (CLUTTER_IS_BOX (box));  g_return_if_fail (CLUTTER_IS_ACTOR (actor));  container = CLUTTER_CONTAINER (box);  clutter_container_add_actor (container, actor);  priv = box->priv;  meta = clutter_layout_manager_get_child_meta (priv->manager,                                                container,                                                actor);  if (meta == NULL)    return;  klass = G_OBJECT_GET_CLASS (meta);  for (i = 0; i < n_properties; i++)    {      const gchar *pname = properties[i];      GParamSpec *pspec;      pspec = g_object_class_find_property (klass, pname);      if (pspec == NULL)        {          g_warning ("%s: the layout property '%s' for managers "                     "of type '%s' (meta type '%s') does not exist",                     G_STRLOC,                     pname,                     G_OBJECT_TYPE_NAME (priv->manager),                     G_OBJECT_TYPE_NAME (meta));          break;        }      if (!(pspec->flags & G_PARAM_WRITABLE))        {          g_warning ("%s: the layout property '%s' for managers "                     "of type '%s' (meta type '%s') is not writable",                     G_STRLOC,                     pspec->name,                     G_OBJECT_TYPE_NAME (priv->manager),                     G_OBJECT_TYPE_NAME (meta));          break;        }      clutter_layout_manager_child_set_property (priv->manager,                                                 container, actor,                                                 pname, &values[i]);    }}

static void manager_event_object_new(unsigned short type, void *userdata, void *data){	na_scene_actor_t		*actor;	tuio_object_t			*o = (tuio_object_t *)data;	manager_actor_t			*el;	ClutterActor			*stage;	uint					wx,							wy;	assert( data != NULL );	/* search actor from scene	 */	actor = na_scene_actor_get(c_scene, o->f_id);	if ( actor == NULL )	{		l_errorf("actor %d not found in scene", o->f_id);		return;	}	/* check rendering module	 */	if ( actor->mod == NULL )	{		l_errorf("no object associated for actor %d", o->f_id);		return;	}	/* create manager actor	 */	el = malloc(sizeof(struct manager_actor_s));	if ( el == NULL )	{		l_errorf("no enough memory to create manager actor");		return;	}	bzero(el, sizeof(struct manager_actor_s));	el->id				= o->s_id;	el->tuio			= o;	el->scene_actor		= actor;	el->clutter_actor	= clutter_group_new();	el->rotate_actor	= clutter_group_new();	clutter_container_add_actor(CLUTTER_CONTAINER(el->clutter_actor), el->rotate_actor);	/* use associed module for rendering	 */	(*actor->mod->object_prepare)(actor->data_mod, el);	/* insert actor into list	 */	LIST_INSERT_HEAD(&manager_actors_list, el, next);	/* retreive last dimensions	 */	stage = clutter_stage_get_default();	clutter_actor_get_size(stage, &wx, &wy);	/* some position	 */	clutter_actor_set_position(el->clutter_actor,		o->xpos * (float)wx,		o->ypos * (float)wy	);	clutter_actor_set_rotation(el->rotate_actor,		CLUTTER_Z_AXIS,		TUIO_PI_TO_DEG(o->angle),		actor->width * 0.5,		actor->height * 0.5,		0	);	/* show actor	 * FIXME not needed ?	 */	clutter_actor_show(el->clutter_actor);	/* add to stage	 */	clutter_container_add_actor(CLUTTER_CONTAINER(stage), el->clutter_actor);	atomic_set(&c_scene_changed, 1);}

static inline voidclutter_box_set_property_valist (ClutterBox   *box,                                 ClutterActor *actor,                                 const gchar  *first_property,                                 va_list       var_args){  ClutterContainer *container = CLUTTER_CONTAINER (box);  ClutterBoxPrivate *priv = box->priv;  ClutterLayoutMeta *meta;  GObjectClass *klass;  const gchar *pname;  if (priv->manager == NULL)    return;  meta = clutter_layout_manager_get_child_meta (priv->manager,                                                container,                                                actor);  if (meta == NULL)    return;  klass = G_OBJECT_GET_CLASS (meta);  pname = first_property;  while (pname)    {      GValue value = { 0, };      GParamSpec *pspec;      gchar *error;      pspec = g_object_class_find_property (klass, pname);      if (pspec == NULL)        {          g_warning ("%s: the layout property '%s' for managers "                     "of type '%s' (meta type '%s') does not exist",                     G_STRLOC,                     pname,                     G_OBJECT_TYPE_NAME (priv->manager),                     G_OBJECT_TYPE_NAME (meta));          break;        }      if (!(pspec->flags & G_PARAM_WRITABLE))        {          g_warning ("%s: the layout property '%s' for managers "                     "of type '%s' (meta type '%s') is not writable",                     G_STRLOC,                     pspec->name,                     G_OBJECT_TYPE_NAME (priv->manager),                     G_OBJECT_TYPE_NAME (meta));          break;        }      G_VALUE_COLLECT_INIT (&value, G_PARAM_SPEC_VALUE_TYPE (pspec),                            var_args, 0,                            &error);      if (error)        {          g_warning ("%s: %s", G_STRLOC, error);          g_free (error);          break;        }      clutter_layout_manager_child_set_property (priv->manager,                                                 container, actor,                                                 pspec->name, &value);      g_value_unset (&value);      pname = va_arg (var_args, gchar*);    }}

static voidpenge_welcome_tile_init (PengeWelcomeTile *tile){  ClutterActor *placeholder_image;  GError *error = NULL;  placeholder_image = clutter_texture_new_from_file (PLACEHOLDER_IMAGE, &error);  if (error != NULL)    {      g_warning ("Couldn't open the placeholder image %s", PLACEHOLDER_IMAGE);      g_clear_error (&error);    }  else    {      ClutterActor *bin;      bin = mx_frame_new ();      clutter_container_add_actor (CLUTTER_CONTAINER (bin),          placeholder_image);      clutter_actor_set_name (bin,                              "penge-welcome-placeholder-margin");      clutter_actor_set_name (placeholder_image,                              "penge-welcome-placeholder");      clutter_actor_set_size (placeholder_image, 548, 247);      mx_table_insert_actor_with_properties (MX_TABLE (tile),                                             bin,                                             0, 0,                                             "x-expand", TRUE,                                             "y-expand", TRUE,                                             "x-fill", TRUE,                                             "y-fill", TRUE,                                             "x-align", MX_ALIGN_START,                                             NULL);      mx_bin_set_fill (MX_BIN (bin), TRUE, TRUE);    }  /* It's not to be shown  if (g_file_test (WELCOME_VIDEO_FILENAME, G_FILE_TEST_EXISTS))    {      ClutterActor *launcher;      ClutterActor *inner_table;      ClutterActor *icon;      launcher = mx_button_new ();      clutter_actor_set_name (launcher, "penge-welcome-launcher");      inner_table = mx_table_new ();      mx_bin_set_child (MX_BIN (launcher), inner_table);      icon = mx_icon_new ();      clutter_actor_set_name (icon, "penge-welcome-launcher-thumbnail");      mx_table_insert_actor_with_properties (MX_TABLE (inner_table),                                          icon,                                          0, 0,                                          "x-expand", TRUE,                                          "x-fill", TRUE,                                          "y-expand", TRUE,                                          "y-fill", TRUE,                                          NULL);      icon = mx_icon_new ();      clutter_actor_set_name (icon, "penge-welcome-launcher-play-button");      mx_table_insert_actor_with_properties (MX_TABLE (inner_table),                                          icon,                                          0, 0,                                          "x-expand", TRUE,                                          "x-fill", FALSE,                                          "y-expand", TRUE,                                          "y-fill", FALSE,                                          NULL);      mx_table_insert_actor_with_properties (MX_TABLE (tile),                                          launcher,                                          1, 0,                                          "x-expand", FALSE,                                          "x-fill", FALSE,                                          "y-expand", FALSE,                                          "y-fill", FALSE,                                          "x-align", MX_ALIGN_START,                                          NULL);      g_signal_connect (launcher,                        "clicked",                        (GCallback)_welcome_launcher_clicked_cb,                        NULL);    }    */}

intmain (int argc, char *argv[]){  ClutterActor    *stage;  ClutterColor     stage_color = { 0x00, 0x00, 0x00, 0xff };  ClutterActor    *label;  int              w, h;  int              row, col;  float            scale = 1.0f;  g_setenv ("CLUTTER_VBLANK", "none", FALSE);  g_setenv ("CLUTTER_DEFAULT_FPS", "1000", FALSE);  clutter_init (&argc, &argv);  if (argc != 3)    {      g_printerr ("Usage test-text-perf FONT_SIZE N_CHARS/n");      exit (1);    }  font_size = atoi (argv[1]);  n_chars = atoi (argv[2]);  g_print ("Monospace %dpx, string length = %d/n", font_size, n_chars);  stage = clutter_stage_get_default ();  clutter_actor_set_size (stage, STAGE_WIDTH, STAGE_HEIGHT);  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  g_signal_connect (stage, "paint", G_CALLBACK (on_paint), NULL);  label = create_label ();  w = clutter_actor_get_width (label);  h = clutter_actor_get_height (label);  /* If the label is too big to fit on the stage then scale it so that     it will fit */  if (w > STAGE_WIDTH || h > STAGE_HEIGHT)    {      float x_scale = STAGE_WIDTH / (float) w;      float y_scale = STAGE_HEIGHT / (float) h;      if (x_scale < y_scale)        {          scale = x_scale;          cols = 1;          rows = STAGE_HEIGHT / (h * scale);        }      else        {          scale = y_scale;          cols = STAGE_WIDTH / (w * scale);          rows = 1;        }      g_print ("Text scaled by %f to fit on the stage/n", scale);    }  else    {      cols = STAGE_WIDTH / w;      rows = STAGE_HEIGHT / h;    }  clutter_actor_destroy (label);  for (row=0; row<rows; row++)    for (col=0; col<cols; col++)      {	label = create_label();        clutter_actor_set_scale (label, scale, scale);	clutter_actor_set_position (label, w * col * scale, h * row * scale);	clutter_container_add_actor (CLUTTER_CONTAINER (stage), label);      }  clutter_actor_show_all (stage);  g_idle_add (queue_redraw, stage);  clutter_main ();  return 0;}

static gbooleanon_timeout (State *state){  int test_num = 0;  int y, x;  ClutterActor *over_actor = NULL;  for (test_num = 0; test_num < 3; test_num++)    {      if (test_num == 0)        {          if (g_test_verbose ())            g_print ("No covering actor:/n");        }      if (test_num == 1)        {          static const ClutterColor red = { 0xff, 0x00, 0x00, 0xff };          /* Create an actor that covers the whole stage but that             isn't visible so it shouldn't affect the picking */          over_actor = clutter_rectangle_new_with_color (&red);          clutter_actor_set_size (over_actor, STAGE_WIDTH, STAGE_HEIGHT);          clutter_container_add (CLUTTER_CONTAINER (state->stage),                                 over_actor, NULL);          clutter_actor_hide (over_actor);          if (g_test_verbose ())            g_print ("Invisible covering actor:/n");        }      else if (test_num == 2)        {          /* Make the actor visible but set a clip so that only some             of the actors are accessible */          clutter_actor_show (over_actor);          clutter_actor_set_clip (over_actor,                                  state->actor_width * 2,                                  state->actor_height * 2,                                  state->actor_width * (ACTORS_X - 4),                                  state->actor_height * (ACTORS_Y - 4));          if (g_test_verbose ())            g_print ("Clipped covering actor:/n");        }      for (y = 0; y < ACTORS_Y; y++)        for (x = 0; x < ACTORS_X; x++)          {            gboolean pass = FALSE;            guint32 gid;            ClutterActor *actor              = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (state->stage),                                                CLUTTER_PICK_ALL,                                                x * state->actor_width                                                + state->actor_width / 2,                                                y * state->actor_height                                                + state->actor_height / 2);            if (g_test_verbose ())              g_print ("% 3i,% 3i / % 4i -> ",                       x, y, (int) state->gids[y * ACTORS_X + x]);            if (actor == NULL)              {                if (g_test_verbose ())                  g_print ("NULL:       FAIL/n");              }            else if (actor == over_actor)              {                if (test_num == 2                    && x >= 2 && x < ACTORS_X - 2                    && y >= 2 && y < ACTORS_Y - 2)                  pass = TRUE;                if (g_test_verbose ())                  g_print ("over_actor: %s/n", pass ? "pass" : "FAIL");              }            else              {                gid = clutter_actor_get_gid (actor);                if (gid == state->gids[y * ACTORS_X + x]                    && (test_num != 2                        || x < 2 || x >= ACTORS_X - 2                        || y < 2 || y >= ACTORS_Y - 2))                  pass = TRUE;                if (g_test_verbose ())                  g_print ("% 10i: %s/n", gid, pass ? "pass" : "FAIL");              }            if (!pass)              state->pass = FALSE;          }    }  clutter_main_quit ();  return FALSE;}

G_MODULE_EXPORT inttest_snap_constraint_main (int   argc,                           char *argv[]){  ClutterActor *stage, *layer_a, *layer_b, *layer_c;  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  /* the main container */  stage = clutter_stage_new ();  clutter_actor_set_name (stage, "stage");  clutter_stage_set_title (CLUTTER_STAGE (stage), "Snap Constraint");  clutter_stage_set_color (CLUTTER_STAGE (stage), CLUTTER_COLOR_Aluminium1);  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  /* first layer, with a fixed (100, 25) size */  layer_a = clutter_rectangle_new_with_color (CLUTTER_COLOR_ScarletRed);  clutter_actor_set_name (layer_a, "layerA");  clutter_container_add_actor (CLUTTER_CONTAINER (stage), layer_a);  clutter_actor_set_size (layer_a, 100.0, 25.0);  /* the first layer is anchored to the middle of the stage */  clutter_actor_add_constraint (layer_a, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5));  clutter_actor_add_constraint (layer_a, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.5));  /* second layer, with no implicit size */  layer_b = clutter_rectangle_new_with_color (CLUTTER_COLOR_DarkButter);  clutter_actor_set_name (layer_b, "layerB");  clutter_container_add_actor (CLUTTER_CONTAINER (stage), layer_b);  /* the second layer tracks the X coordinate and the width of   * the first layer   */  clutter_actor_add_constraint (layer_b, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_X, 0.0));  clutter_actor_add_constraint (layer_b, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_WIDTH, 0.0));  /* the second layer is snapped between the bottom edge of   * the first layer, and the bottom edge of the stage; a   * spacing of 10 pixels in each direction is added for padding   */  clutter_actor_add_constraint (layer_b,                                clutter_snap_constraint_new (layer_a,                                                             CLUTTER_SNAP_EDGE_TOP,                                                             CLUTTER_SNAP_EDGE_BOTTOM,                                                             10.0));  clutter_actor_add_constraint (layer_b,                                clutter_snap_constraint_new (stage,                                                             CLUTTER_SNAP_EDGE_BOTTOM,                                                             CLUTTER_SNAP_EDGE_BOTTOM,                                                             -10.0));  /* the third layer, with no implicit size */  layer_c = clutter_rectangle_new_with_color (CLUTTER_COLOR_LightChameleon);  clutter_actor_set_name (layer_c, "layerC");  clutter_container_add_actor (CLUTTER_CONTAINER (stage), layer_c);  /* as for the second layer, the third layer tracks the X   * coordinate and width of the first layer   */  clutter_actor_add_constraint (layer_c, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_X, 0.0));  clutter_actor_add_constraint (layer_c, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_WIDTH, 0.0));  /* the third layer is snapped between the top edge of the stage   * and the top edge of the first layer; again, a spacing of   * 10 pixels in each direction is added for padding   */  clutter_actor_add_constraint (layer_c,                                clutter_snap_constraint_new (layer_a,                                                             CLUTTER_SNAP_EDGE_BOTTOM,                                                             CLUTTER_SNAP_EDGE_TOP,                                                             -10.0));  clutter_actor_add_constraint (layer_c,                                clutter_snap_constraint_new (stage,                                                             CLUTTER_SNAP_EDGE_TOP,                                                             CLUTTER_SNAP_EDGE_TOP,                                                             10.0));  clutter_actor_show (stage);  clutter_main ();  return EXIT_SUCCESS;}

intmain (int   argc,      char *argv[]){  ClutterActor *stage;  ClutterActor *texture;  gchar *image_path;  GError *error = NULL;  if (argc < 2)    {      g_print ("Usage: %s <path to image file>/n", argv[0]);      exit (EXIT_FAILURE);    }  image_path = argv[1];  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  stage = clutter_stage_new ();  clutter_actor_set_size (stage, STAGE_SIDE, STAGE_SIDE);  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  texture = clutter_texture_new ();  clutter_actor_set_reactive (texture, TRUE);  clutter_actor_set_width (texture, STAGE_SIDE);  clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (texture), TRUE);  clutter_actor_add_action (texture, clutter_drag_action_new ());  g_object_set (G_OBJECT (texture),                "scale-gravity", CLUTTER_GRAVITY_NORTH_WEST,                NULL);  clutter_texture_set_from_file (CLUTTER_TEXTURE (texture), image_path, &error);  if (error != NULL)    {      g_warning ("Error loading %s/n%s", image_path, error->message);      g_error_free (error);      exit (EXIT_FAILURE);    }  clutter_actor_set_y (texture, (STAGE_SIDE - clutter_actor_get_height (texture)) * 0.5);  g_signal_connect (texture,                    "button-release-event",                    G_CALLBACK (clicked_cb),                    NULL);  g_signal_connect_swapped (stage,                            "key-press-event",                            G_CALLBACK (key_press_cb),                            texture);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), texture);  clutter_actor_show (stage);  clutter_main ();  return EXIT_SUCCESS;}

static gint *st_table_calculate_col_widths (StTable *table,                               gint     for_width){  gint total_min_width, i;  StTablePrivate *priv = table->priv;  gboolean *is_expand_col;  gint extra_col_width, n_expanded_cols = 0, expanded_cols = 0;  gint *pref_widths, *min_widths;  ClutterActor *child;  g_array_set_size (priv->is_expand_col, 0);  g_array_set_size (priv->is_expand_col, priv->n_cols);  is_expand_col = (gboolean *) priv->is_expand_col->data;  g_array_set_size (priv->pref_widths, 0);  g_array_set_size (priv->pref_widths, priv->n_cols);  pref_widths = (gint *) priv->pref_widths->data;  g_array_set_size (priv->min_widths, 0);  g_array_set_size (priv->min_widths, priv->n_cols);  min_widths = (gint *) priv->min_widths->data;  for (child = clutter_actor_get_first_child (CLUTTER_ACTOR (table));       child != NULL;       child = clutter_actor_get_next_sibling (child))    {      gint col;      gfloat w_min, w_pref;      gboolean x_expand;      StTableChild *meta;      gint col_span;      meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);      if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))        continue;      /* get child properties */      col = meta->col;      x_expand = meta->x_expand;      col_span = meta->col_span;      if (x_expand)        is_expand_col[col] = TRUE;      _st_actor_get_preferred_width (child, -1, meta->y_fill, &w_min, &w_pref);      if (col_span == 1 && w_pref > pref_widths[col])        {          pref_widths[col] = w_pref;        }      if (col_span == 1 && w_min > min_widths[col])        {          min_widths[col] = w_min;        }    }  total_min_width = priv->col_spacing * (priv->n_cols - 1);  for (i = 0; i < priv->n_cols; i++)    total_min_width += pref_widths[i];  /* calculate the remaining space and distribute it evenly onto all rows/cols   * with the x/y expand property set. */  for (i = 0; i < priv->n_cols; i++)    if (is_expand_col[i])      {        expanded_cols += pref_widths[i];        n_expanded_cols++;      }  /* for_width - total_min_width */  extra_col_width = for_width - total_min_width;  if (extra_col_width)    for (i = 0; i < priv->n_cols; i++)      if (is_expand_col[i])        {          if (extra_col_width < 0)            {              pref_widths[i] =                MAX (min_widths[i],                     pref_widths[i]                     + (extra_col_width * (pref_widths[i] / (float) expanded_cols)));              /* if we reached the minimum width for this column, we need to               * stop counting it as expanded */              if (pref_widths[i] == min_widths[i])                {                  /* restart calculations :-( */                  expanded_cols -= pref_widths[i];                  is_expand_col[i] = 0;                  n_expanded_cols--;                  i = -1;                }            }          else            pref_widths[i] += extra_col_width / n_expanded_cols;        }  return pref_widths;//.........这里部分代码省略.........

static voidon_new_kinect_device (GObject      *obj,                      GAsyncResult *res,                      gpointer      user_data){  ClutterActor *stage, *instructions;  GError *error = NULL;  gint width = 640;  gint height = 480;  kinect = gfreenect_device_new_finish (res, &error);  if (kinect == NULL)    {      g_debug ("Failed to created kinect device: %s", error->message);      g_error_free (error);      clutter_main_quit ();      return;    }  g_debug ("Kinect device created!");  stage = clutter_stage_get_default ();  clutter_stage_set_title (CLUTTER_STAGE (stage), "Kinect Test");  clutter_actor_set_size (stage, width * 2, height + 200);  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);  g_signal_connect (stage, "destroy", G_CALLBACK (on_destroy), kinect);  g_signal_connect (stage,                    "key-release-event",                    G_CALLBACK (on_key_release),                    kinect);  depth_tex = clutter_cairo_texture_new (width, height);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), depth_tex);  video_tex = clutter_cairo_texture_new (width, height);  clutter_actor_set_position (video_tex, width, 0.0);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), video_tex);  info_text = clutter_text_new ();  set_info_text ();  clutter_actor_set_position (info_text, 50, height + 20);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), info_text);  instructions = create_instructions ();  clutter_actor_set_position (instructions, 50, height + 70);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), instructions);  clutter_actor_show_all (stage);  skeleton = SKELTRACK_SKELETON (skeltrack_skeleton_new ());  g_signal_connect (kinect,                    "depth-frame",                    G_CALLBACK (on_depth_frame),                    NULL);  g_signal_connect (kinect,                    "video-frame",                    G_CALLBACK (on_video_frame),                    NULL);  g_signal_connect (depth_tex,                    "draw",                    G_CALLBACK (on_texture_draw),                    NULL);  gfreenect_device_set_tilt_angle (kinect, 0, NULL, NULL, NULL);  gfreenect_device_start_depth_stream (kinect,                                       GFREENECT_DEPTH_FORMAT_MM,                                       NULL);  gfreenect_device_start_video_stream (kinect,                                       GFREENECT_RESOLUTION_MEDIUM,                                       GFREENECT_VIDEO_FORMAT_RGB, NULL);}

static voidst_table_preferred_allocate (ClutterActor          *self,                             const ClutterActorBox *content_box,                             gboolean               flags){  gint row_spacing, col_spacing;  gint i;  gint *col_widths, *row_heights;  StTable *table;  StTablePrivate *priv;  gboolean ltr;  ClutterActor *child;  table = ST_TABLE (self);  priv = ST_TABLE (self)->priv;  col_spacing = (priv->col_spacing);  row_spacing = (priv->row_spacing);  col_widths =    st_table_calculate_col_widths (table,                                   (int) (content_box->x2 - content_box->x1));  row_heights =    st_table_calculate_row_heights (table,                                    (int) (content_box->y2 - content_box->y1),                                    col_widths);  ltr = (clutter_actor_get_text_direction (self) == CLUTTER_TEXT_DIRECTION_LTR);  for (child = clutter_actor_get_first_child (self);       child != NULL;       child = clutter_actor_get_next_sibling (child))    {      gint row, col, row_span, col_span;      gint col_width, row_height;      StTableChild *meta;      ClutterActorBox childbox;      gint child_x, child_y;      gdouble x_align_f, y_align_f;      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;      _st_get_align_factors (meta->x_align, meta->y_align,                             &x_align_f, &y_align_f);      /* initialise the width and height */      col_width = col_widths[col];      row_height = row_heights[row];      /* 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: col-span exceeds number of columns");#if 0      if (row + row_span > priv->n_rows)        g_warning ("StTable: row-span exceeds number of rows");#endif      if (col_span > 1)        {          for (i = col + 1; i < col + col_span && i < priv->n_cols; i++)            {              col_width += col_widths[i];              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 += row_heights[i];              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 += col_widths[i];        }//.........这里部分代码省略.........

static gbooleanactor_manipulator_press (ClutterActor *stage,                         ClutterEvent *event,                         gpointer      data){  ClutterActor *actor;  actor = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (stage),                                          CLUTTER_PICK_ALL,                                          event->button.x,                                          event->button.y);  if (actor == stage ||      CLUTTER_IS_GROUP (actor))    {      if (event->button.button == 3)        {          popup_nuke (stage, event->button.x, event->button.y);          popup_add ("+rectangle", "bar", G_CALLBACK (                       action_add_rectangle), scene_get_group ());          popup_add ("+circle", "bar", G_CALLBACK (                       action_add_circle), scene_get_group ());          popup_add ("+triangle", "bar", G_CALLBACK (                       action_add_triangle), scene_get_group ());          popup_add ("+text", "bar", G_CALLBACK (                       action_add_text), scene_get_group ());          popup_add ("+image", "bar", G_CALLBACK (                       action_add_image), scene_get_group ());#if 0          popup_add ("+block-tree", "bar", G_CALLBACK (                       action_add_block_tree), scene_get_group ());#endif          popup_add ("zero gravity", "bar", G_CALLBACK (                       action_zero_gravity), scene_get_group ());        }      return TRUE;    }  if (actor == NULL)    {      return FALSE;    }  if (event->button.button == 3)    {      popup_nuke (stage, event->button.x, event->button.y);      popup_add ("remove", "bar", G_CALLBACK (action_remove), actor);      popup_add ("set linear velocity", "bar", G_CALLBACK (action_set_linear_velocity), actor);      popup_add ("set dynamic", "bar", G_CALLBACK (action_set_dynamic), actor);      popup_add ("set static", "bar", G_CALLBACK (action_set_static), actor);      popup_add_slider ("opacity", "hm", 0.0, 255.0,                        clutter_actor_get_opacity (actor) * 1.0,                        G_CALLBACK (set_opacity), actor);      popup_add_slider ("rotation", "hm", 0.0, 360.0,                        clutter_actor_get_rotation (actor, CLUTTER_Z_AXIS, NULL,                                                    NULL, NULL),                        G_CALLBACK (set_rotation), actor);      popup_add ("ok", "bar", NULL, NULL);      return TRUE;    }  if (!should_be_manipulated (actor))    return FALSE;  manipulated_actor = actor;  clutter_actor_get_position (actor, &orig_x, &orig_y);  orig_rotation = clutter_actor_get_rotation (actor, CLUTTER_Z_AXIS, NULL,                                               NULL,                                               NULL);  start_x =  (event->button.x);  start_y =  (event->button.y);  clutter_actor_transform_stage_point (    clutter_actor_get_parent (manipulated_actor),    start_x, start_y,    &start_x, &start_y);  mode = Direct;#ifdef BOX2D_MANIPULATION  /* Use Box2D manipulation if the actor is dynamic, and the physics   * engine is running   */  if (CLUTTER_IS_BOX2D (scene_get_group ()) &&      clutter_box2d_get_simulating (CLUTTER_BOX2D (scene_get_group ())))    {      ClutterBox2D *box2d  = CLUTTER_BOX2D (scene_get_group ());      /*ClutterVertex target = { start_x, start_y };*/      gint type;            clutter_container_child_get (CLUTTER_CONTAINER (box2d),                                   manipulated_actor, "mode", &type, NULL);      	  //.........这里部分代码省略.........

static voidst_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 int mp_constructor(TPMediaPlayer * mp){    static int init=0;    if (!init)    {        init=1;        gst_init(NULL,NULL);    }    ClutterActor * video_texture=clutter_gst_video_texture_new();    if (!video_texture)    {        g_warning("FAILED TO CREATE CLUTTER GST VIDEO TEXTURE");        return TP_MEDIAPLAYER_ERROR_NO_MEDIAPLAYER;    }    // We own it    g_object_ref_sink(G_OBJECT(video_texture));    // Get the stage, size the video texture and add it to the stage    clutter_actor_hide(video_texture);    ClutterActor * stage=clutter_stage_get_default();    gfloat width,height;    clutter_actor_get_size(stage,&width,&height);    clutter_actor_set_size(video_texture,width,height);    clutter_actor_set_position(video_texture,0,0);    clutter_container_add_actor(CLUTTER_CONTAINER(stage),video_texture);    clutter_actor_lower_bottom(video_texture);    g_signal_connect( stage , "notify::allocation" , ( GCallback ) stage_allocation_notify , video_texture );    // Connect signals    g_signal_connect(video_texture,"eos",G_CALLBACK(mp_end_of_stream),mp);    g_signal_connect(video_texture,"error",G_CALLBACK(mp_error),mp);    // We use gmalloc0 to zero out the whole structure    UserData * user_data=(UserData*) g_malloc0(sizeof(UserData));    user_data->vt=video_texture;    mp->user_data=user_data;    mp->destroy=mp_destroy;    mp->load=mp_load;    mp->reset=mp_reset;    mp->play=mp_play;    mp->seek=mp_seek;    mp->pause=mp_pause;    mp->set_playback_rate=mp_set_playback_rate;    mp->get_position=mp_get_position;    mp->get_duration=mp_get_duration;    mp->get_buffered_duration=mp_get_buffered_duration;    mp->get_video_size=mp_get_video_size;    mp->get_viewport_geometry=mp_get_viewport_geometry;    mp->set_viewport_geometry=mp_set_viewport_geometry;    mp->get_media_type=mp_get_media_type;    mp->get_audio_volume=mp_get_audio_volume;    mp->set_audio_volume=mp_set_audio_volume;    mp->get_audio_mute=mp_get_audio_mute;    mp->set_audio_mute=mp_set_audio_mute;    mp->play_sound=mp_play_sound;    mp->get_viewport_texture=mp_get_viewport_texture;    return 0;}

static voidmx_stack_allocate (ClutterActor           *actor,                   const ClutterActorBox  *box,                   ClutterAllocationFlags  flags){  GList *c;  ClutterActorBox avail_space;  MxStackPrivate *priv = MX_STACK (actor)->priv;  CLUTTER_ACTOR_CLASS (mx_stack_parent_class)->allocate (actor, box, flags);  mx_widget_get_available_area (MX_WIDGET (actor), box, &avail_space);  memcpy (&priv->allocation, box, sizeof (priv->allocation));  for (c = priv->children; c; c = c->next)    {      gboolean x_fill, y_fill, fit, crop;      MxAlign x_align, y_align;      ClutterActor *child = c->data;      ClutterActorBox child_box = avail_space;      if (!CLUTTER_ACTOR_IS_VISIBLE (child))        continue;      clutter_container_child_get (CLUTTER_CONTAINER (actor),                                   child,                                   "x-fill", &x_fill,                                   "y-fill", &y_fill,                                   "x-align", &x_align,                                   "y-align", &y_align,                                   "fit", &fit,                                   "crop", &crop,                                   NULL);      /* when "crop" is set, fit and fill properties are ignored */      if (crop)        {          gfloat available_height, available_width;          gfloat natural_width, natural_height;          gfloat ratio_width, ratio_height, ratio_child;          available_width  = avail_space.x2 - avail_space.x1;          available_height = avail_space.y2 - avail_space.y1;          clutter_actor_get_preferred_size (child,                                            NULL, NULL,                                            &natural_width,                                            &natural_height);          ratio_child = natural_width / natural_height;          ratio_width = available_width / natural_width;          ratio_height = available_height / natural_height;          if (ratio_width > ratio_height)            {              natural_width = available_width;              natural_height = natural_width / ratio_child;            }          else            {              natural_height = available_height;              natural_width = ratio_child * natural_height;            }          child_box.x1 = (available_width - natural_width) / 2;          child_box.y1 = (available_height - natural_height) / 2;          child_box.x2 = natural_width;          child_box.y2 = natural_height;          clutter_actor_allocate (child, &child_box, flags);          continue;        }      /* when "fit" is set, fill properties are ignored */      if (fit)        {          gfloat available_height, available_width, width, height;          gfloat min_width, natural_width, min_height, natural_height;          ClutterRequestMode request_mode;          available_height = avail_space.y2 - avail_space.y1;          available_width  = avail_space.x2 - avail_space.x1;          request_mode = clutter_actor_get_request_mode (child);          if (request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)            {              clutter_actor_get_preferred_width (child, available_height,                                                 &min_width,                                                 &natural_width);              width = CLAMP (natural_width, min_width, available_width);              clutter_actor_get_preferred_height (child, width,                                                  &min_height,                                                  &natural_height);              height = CLAMP (natural_height, min_height, available_height);            }          else            {//.........这里部分代码省略.........

static gboolean bar_pane_gps_create_markers_cb(gpointer data){	PaneGPSData *pgd = data;	gdouble latitude;	gdouble longitude;	GList *work;	ClutterActor *marker;	FileData *fd;	ClutterColor marker_colour = { MARKER_COLOUR };	GString *message;	gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pgd->progress),							(gdouble)(pgd->selection_count - g_list_length(pgd->selection_list)) /							(gdouble)pgd->selection_count);								message = g_string_new("");	g_string_printf(message, "%i/%i", (pgd->selection_count - g_list_length(pgd->selection_list)),																			pgd->selection_count);	gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pgd->progress), message->str);	g_string_free(message, TRUE);		work = pgd->selection_list;	while (work)		{		fd = work->data;		pgd->selection_list = g_list_remove(pgd->selection_list, work->data);		/* If the file has a parent, it must be a sidecar file. Do not process sidecar files		*/		if (fd != NULL && fd->parent == NULL)			{			latitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLatitude", 1000);			longitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLongitude", 1000);			if ((latitude != 1000) && (longitude != 1000))				{				marker = champlain_marker_new_with_text("i","courier 5", &marker_colour, &marker_colour);				champlain_base_marker_set_position(CHAMPLAIN_BASE_MARKER(marker), latitude, longitude);				clutter_container_add(CLUTTER_CONTAINER(pgd->icon_layer), marker, NULL);				clutter_actor_set_reactive(marker, TRUE);				g_signal_connect(G_OBJECT(marker), "button_release_event",						 				G_CALLBACK(bar_pane_gps_marker_keypress_cb), pgd);				g_object_set_data(G_OBJECT(marker), "file_fd", fd);				g_ptr_array_add(pgd->marker_list, marker);				if (pgd->centre_map_checked)					{					g_ptr_array_add(pgd->marker_list, NULL);					champlain_view_ensure_markers_visible(CHAMPLAIN_VIEW(pgd->gps_view),													(void *)pgd->marker_list->pdata, FALSE);					g_ptr_array_remove(pgd->marker_list, NULL);					}				}			}		return TRUE;		}			if (pgd->marker_list->len >= 1)		{		g_ptr_array_add(pgd->marker_list, NULL);		if (pgd->centre_map_checked)			{			champlain_view_ensure_markers_visible(CHAMPLAIN_VIEW(pgd->gps_view), (void *)pgd->marker_list->pdata, FALSE);			}		}	gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pgd->progress), 0);	gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pgd->progress), NULL);	g_list_free(pgd->selection_list);	g_ptr_array_free(pgd->marker_list, TRUE);	pgd->create_markers_id = 0;	return FALSE;}