本文整理汇总了C++中CLUTTER_ACTOR函数的典型用法代码示例。如果您正苦于以下问题:C++ CLUTTER_ACTOR函数的具体用法?C++ CLUTTER_ACTOR怎么用?C++ CLUTTER_ACTOR使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了CLUTTER_ACTOR函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: setup_window
static void
setup_window (void)
{
GtkWidget *vbox;
GtkWidget *packing;
GtkWidget *menubar;
GtkUIManager *ui_manager;
GtkAccelGroup *accel_group;
ClutterColor stage_color = {0x00,0x00,0x00,0xff};
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
clutter_widget = gtk_clutter_embed_new ();
stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (clutter_widget));
clutter_stage_set_color (CLUTTER_STAGE(stage), &stage_color);
clutter_actor_set_size (CLUTTER_ACTOR (stage),
properties->tilesize * BOARDWIDTH,
properties->tilesize * BOARDHEIGHT);
clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), FALSE);
board = gnibbles_board_new ();
gtk_window_set_title (GTK_WINDOW (window), _("Nibbles"));
gtk_window_set_default_size (GTK_WINDOW (window),
DEFAULT_WIDTH, DEFAULT_HEIGHT);
games_conf_add_window (GTK_WINDOW (window), KEY_PREFERENCES_GROUP);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (delete_cb), NULL);
g_signal_connect (G_OBJECT (window), "window_state_event",
G_CALLBACK (window_state_cb), NULL);
gtk_widget_realize (window);
vbox = gtk_vbox_new (FALSE, 0);
games_stock_init ();
ui_manager = gtk_ui_manager_new ();
create_menus (ui_manager);
set_fullscreen_actions (FALSE);
notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
menubar = gtk_ui_manager_get_widget (ui_manager, "/MainMenu");
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
packing = games_grid_frame_new (BOARDWIDTH, BOARDHEIGHT);
gtk_widget_show (packing);
gtk_container_add (GTK_CONTAINER (packing), clutter_widget);
#ifdef GGZ_CLIENT
chat = create_chat_widget ();
gtk_box_pack_start (GTK_BOX (vbox), chat, FALSE, TRUE, 0);
#endif
g_signal_connect (G_OBJECT (clutter_widget), "configure_event",
G_CALLBACK (configure_event_cb), NULL);
g_signal_connect (G_OBJECT (window), "focus_out_event",
G_CALLBACK (show_cursor_cb), NULL);
gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), packing, NULL);
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), MAIN_PAGE);
statusbar = gtk_statusbar_new ();
gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show_all (window);
#ifdef GGZ_CLIENT
gtk_widget_hide (chat);
#endif
scoreboard = gnibbles_scoreboard_new (statusbar);
}
示例2: _xfdashboard_application_quit
/* Quit application depending on daemon mode and force parameter */
static void _xfdashboard_application_quit(XfdashboardApplication *self, gboolean inForceQuit)
{
XfdashboardApplicationPrivate *priv;
gboolean shouldQuit;
GSList *stages, *entry;
g_return_if_fail(XFDASHBOARD_IS_APPLICATION(self));
priv=self->priv;
shouldQuit=FALSE;
/* Check if we should really quit this instance */
if(inForceQuit==TRUE || priv->isDaemon==FALSE) shouldQuit=TRUE;
/* Do nothing if application is already quitting. This can happen if
* application is running in daemon mode (primary instance) and another
* instance was called with "quit" or "restart" parameter which would
* cause this function to be called twice.
*/
if(priv->isQuitting) return;
/* If application is not in daemon mode or if forced is set to TRUE
* destroy all stage windows ...
*/
if(shouldQuit==TRUE)
{
/* Set flag that application is going to quit */
priv->isQuitting=TRUE;
/* If application is told to quit, set the restart style to something
* where it won't restart itself.
*/
if(priv->sessionManagementClient &&
XFCE_IS_SM_CLIENT(priv->sessionManagementClient))
{
xfce_sm_client_set_restart_style(priv->sessionManagementClient, XFCE_SM_CLIENT_RESTART_NORMAL);
}
/* Destroy stages */
stages=clutter_stage_manager_list_stages(clutter_stage_manager_get_default());
for(entry=stages; entry!=NULL; entry=g_slist_next(entry)) clutter_actor_destroy(CLUTTER_ACTOR(entry->data));
g_slist_free(stages);
/* Emit "quit" signal */
g_signal_emit(self, XfdashboardApplicationSignals[SIGNAL_QUIT], 0);
/* Really quit application here and now */
if(priv->inited) clutter_main_quit();
}
/* ... otherwise emit "suspend" signal */
else
{
/* Only send signal if not suspended already */
if(!priv->isSuspended)
{
/* Send signal */
g_signal_emit(self, XfdashboardApplicationSignals[SIGNAL_SUSPEND], 0);
/* Set flag for suspension */
priv->isSuspended=TRUE;
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardApplicationProperties[PROP_SUSPENDED]);
}
}
}
示例3: clutter_flow_layout_get_preferred_height
static void
clutter_flow_layout_get_preferred_height (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_width,
gfloat *min_height_p,
gfloat *nat_height_p)
{
ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (manager)->priv;
gint n_columns, line_item_count, line_count;
gfloat total_min_height, total_natural_height;
gfloat line_min_height, line_natural_height;
gfloat max_min_height, max_natural_height;
ClutterActor *actor, *child;
ClutterActorIter iter;
gfloat item_x;
n_columns = get_columns (CLUTTER_FLOW_LAYOUT (manager), for_width);
total_min_height = 0;
total_natural_height = 0;
line_min_height = 0;
line_natural_height = 0;
line_item_count = 0;
line_count = 0;
item_x = 0;
actor = CLUTTER_ACTOR (container);
/* clear the line height arrays */
if (priv->line_min != NULL)
g_array_free (priv->line_min, TRUE);
if (priv->line_natural != NULL)
g_array_free (priv->line_natural, TRUE);
priv->line_min = g_array_sized_new (FALSE, FALSE,
sizeof (gfloat),
16);
priv->line_natural = g_array_sized_new (FALSE, FALSE,
sizeof (gfloat),
16);
if (clutter_actor_get_n_children (actor) != 0)
line_count = 1;
max_min_height = max_natural_height = 0;
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
{
gfloat child_min, child_natural;
gfloat new_x, item_width;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
if (priv->orientation == CLUTTER_FLOW_HORIZONTAL && for_width > 0)
{
clutter_actor_get_preferred_width (child, -1,
&child_min,
&child_natural);
if ((priv->snap_to_grid && line_item_count == n_columns) ||
(!priv->snap_to_grid && item_x + child_natural > for_width))
{
total_min_height += line_min_height;
total_natural_height += line_natural_height;
g_array_append_val (priv->line_min,
line_min_height);
g_array_append_val (priv->line_natural,
line_natural_height);
line_min_height = line_natural_height = 0;
line_item_count = 0;
line_count += 1;
item_x = 0;
}
if (priv->snap_to_grid)
{
new_x = ((line_item_count + 1) * (for_width + priv->col_spacing))
/ n_columns;
item_width = new_x - item_x - priv->col_spacing;
}
else
{
new_x = item_x + child_natural + priv->col_spacing;
item_width = child_natural;
}
clutter_actor_get_preferred_height (child, item_width,
&child_min,
&child_natural);
line_min_height = MAX (line_min_height, child_min);
//.........这里部分代码省略.........
示例4: mx_button_style_changed
static void
mx_button_style_changed (MxWidget *widget)
{
MxButton *button = MX_BUTTON (widget);
MxButtonPrivate *priv = button->priv;
MxBorderImage *content_image = NULL;
/* update the label styling */
mx_button_update_label_style (button);
g_free (priv->style_icon_name);
mx_stylable_get (MX_STYLABLE (widget),
"x-mx-content-image", &content_image,
"x-mx-icon-name", &priv->style_icon_name,
"x-mx-icon-size", &priv->style_icon_size,
NULL);
if (content_image && content_image->uri)
{
if (priv->content_image)
{
clutter_actor_remove_child (CLUTTER_ACTOR (widget),
priv->content_image);
}
priv->content_image =
(ClutterActor*) mx_texture_cache_get_texture (mx_texture_cache_get_default (),
content_image->uri);
if (priv->content_image)
clutter_actor_add_child (CLUTTER_ACTOR (widget), priv->content_image);
else
g_warning ("Could not load content image \"%s\"", content_image->uri);
g_boxed_free (MX_TYPE_BORDER_IMAGE, content_image);
return;
}
else
{
/* remove any previous content image */
if (priv->content_image)
{
clutter_actor_remove_child (CLUTTER_ACTOR (widget),
priv->content_image);
priv->content_image = NULL;
}
if (content_image)
g_boxed_free (MX_TYPE_BORDER_IMAGE, content_image);
}
if (priv->icon_size == 0)
mx_icon_set_icon_size (MX_ICON (priv->icon), priv->style_icon_size);
if (priv->style_icon_name && !priv->icon_name)
{
mx_icon_set_icon_name (MX_ICON (priv->icon), priv->style_icon_name);
mx_button_update_contents (button);
}
}
示例5: mex_telepathy_channel_on_src_pad_added
static void
mex_telepathy_channel_on_src_pad_added (TfContent *content,
TpHandle handle,
FsStream *stream,
GstPad *pad,
FsCodec *codec,
gpointer user_data)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (user_data);
MexTelepathyChannelPrivate *priv = self->priv;
gchar *cstr = fs_codec_to_string (codec);
FsMediaType mtype;
GstPad *sinkpad;
GstElement *element;
GstStateChangeReturn ret;
/* Upon pad added, clear the "in progress" box+padding */
clutter_actor_hide (CLUTTER_ACTOR (priv->busy_box));
clutter_actor_show (CLUTTER_ACTOR (priv->full_frame) );
MEX_DEBUG ("New src pad: %s", cstr);
g_object_get (content, "media-type", &mtype, NULL);
switch (mtype)
{
case FS_MEDIA_TYPE_AUDIO:
element = gst_parse_bin_from_description (
"audioconvert ! audioresample ! audioconvert ! autoaudiosink",
TRUE, NULL);
break;
case FS_MEDIA_TYPE_VIDEO:
element = priv->incoming_sink;
break;
default:
MEX_WARNING ("Unknown media type");
return;
}
if (!gst_bin_add (GST_BIN (priv->pipeline), element))
{
MEX_WARNING ("Failed to add sink element to pipeline");
}
sinkpad = gst_element_get_pad (element, "sink");
ret = gst_element_set_state (element, GST_STATE_PLAYING);
if (ret == GST_STATE_CHANGE_FAILURE)
{
tp_channel_close_async (TP_CHANNEL (priv->channel), NULL, NULL);
MEX_WARNING ("Failed to start tee sink pipeline !?");
return;
}
if (GST_PAD_LINK_FAILED (gst_pad_link (pad, sinkpad)))
{
tp_channel_close_async (TP_CHANNEL (priv->channel), NULL, NULL);
MEX_WARNING ("Couldn't link sink pipeline !?");
return;
}
g_object_unref (sinkpad);
/* Start in FULL mode */
mex_telepathy_channel_set_tool_mode (self, TOOL_MODE_FULL, 100);
}
示例6: mnb_zones_preview_change_workspace
void
mnb_zones_preview_change_workspace (MnbZonesPreview *preview,
gint workspace)
{
gboolean reset_anim;
MnbZonesPreviewPrivate *priv = preview->priv;
/* If we're already going towards this workspace, ignore */
if ((priv->dest_workspace == workspace) && priv->anim_phase)
return;
/* Figure out what we need to be doing with this animation */
switch (priv->anim_phase)
{
default:
case MNB_ZP_STATIC:
/* We weren't animating, start a new one */
reset_anim = TRUE;
break;
case MNB_ZP_ZOOM_OUT:
/* If we're on the right workspace, zoom in and finish, otherwise
* continue the animation like normal.
*/
if (priv->dest_workspace == workspace)
{
priv->anim_phase = MNB_ZP_PAN;
reset_anim = TRUE;
}
else
reset_anim = FALSE;
break;
case MNB_ZP_PAN:
/* If we're heading towards the right workspace, continue the
* animation, otherwise change direction.
*/
if (priv->dest_workspace != workspace)
{
priv->anim_phase = MNB_ZP_ZOOM_OUT;
reset_anim = TRUE;
}
else
reset_anim = FALSE;
break;
case MNB_ZP_ZOOM_IN:
/* Restart the animation if we're not heading towards the right
* workspace.
*/
if (priv->dest_workspace != workspace)
{
priv->anim_phase = MNB_ZP_STATIC;
reset_anim = TRUE;
}
else
reset_anim = FALSE;
break;
}
priv->dest_workspace = workspace;
if (reset_anim)
{
ClutterAnimation *animation =
clutter_actor_get_animation (CLUTTER_ACTOR (preview));
if (animation)
g_signal_handlers_disconnect_by_func (animation,
mnb_zones_preview_completed_cb,
preview);
mnb_zones_preview_completed_cb (animation, preview);
}
}
示例7: st_texture_cache_load_gicon
//.........这里部分代码省略.........
* This method returns a new #ClutterActor for a given #GIcon. If the
* icon isn't loaded already, the texture will be filled
* asynchronously.
*
* Return Value: (transfer none): A new #ClutterActor for the icon, or %NULL if not found
*/
ClutterActor *
st_texture_cache_load_gicon (StTextureCache *cache,
StThemeNode *theme_node,
GIcon *icon,
gint size,
gint scale)
{
AsyncTextureLoadData *request;
ClutterActor *texture;
char *gicon_string;
char *key;
GtkIconTheme *theme;
GtkIconInfo *info;
StTextureCachePolicy policy;
StIconColors *colors = NULL;
StIconStyle icon_style = ST_ICON_STYLE_REQUESTED;
GtkIconLookupFlags lookup_flags;
if (theme_node)
{
colors = st_theme_node_get_icon_colors (theme_node);
icon_style = st_theme_node_get_icon_style (theme_node);
}
/* Do theme lookups in the main thread to avoid thread-unsafety */
theme = cache->priv->icon_theme;
lookup_flags = GTK_ICON_LOOKUP_USE_BUILTIN;
if (icon_style == ST_ICON_STYLE_REGULAR)
lookup_flags |= GTK_ICON_LOOKUP_FORCE_REGULAR;
else if (icon_style == ST_ICON_STYLE_SYMBOLIC)
lookup_flags |= GTK_ICON_LOOKUP_FORCE_SYMBOLIC;
if (clutter_get_default_text_direction () == CLUTTER_TEXT_DIRECTION_RTL)
lookup_flags |= GTK_ICON_LOOKUP_DIR_RTL;
else
lookup_flags |= GTK_ICON_LOOKUP_DIR_LTR;
info = gtk_icon_theme_lookup_by_gicon_for_scale (theme, icon, size, scale, lookup_flags);
if (info == NULL)
return NULL;
gicon_string = g_icon_to_string (icon);
/* A return value of NULL indicates that the icon can not be serialized,
* so don't have a unique identifier for it as a cache key, and thus can't
* be cached. If it is cachable, we hardcode a policy of FOREVER here for
* now; we should actually blow this away on icon theme changes probably */
policy = gicon_string != NULL ? ST_TEXTURE_CACHE_POLICY_FOREVER
: ST_TEXTURE_CACHE_POLICY_NONE;
if (colors)
{
/* This raises some doubts about the practice of using string keys */
key = g_strdup_printf (CACHE_PREFIX_ICON "%s,size=%d,scale=%d,style=%d,colors=%2x%2x%2x%2x,%2x%2x%2x%2x,%2x%2x%2x%2x,%2x%2x%2x%2x",
gicon_string, size, scale, icon_style,
colors->foreground.red, colors->foreground.blue, colors->foreground.green, colors->foreground.alpha,
colors->warning.red, colors->warning.blue, colors->warning.green, colors->warning.alpha,
colors->error.red, colors->error.blue, colors->error.green, colors->error.alpha,
colors->success.red, colors->success.blue, colors->success.green, colors->success.alpha);
}
else
{
key = g_strdup_printf (CACHE_PREFIX_ICON "%s,size=%d,scale=%d,style=%d",
gicon_string, size, scale, icon_style);
}
g_free (gicon_string);
texture = (ClutterActor *) create_default_texture ();
clutter_actor_set_size (texture, size * scale, size * scale);
if (ensure_request (cache, key, policy, &request, texture))
{
/* If there's an outstanding request, we've just added ourselves to it */
g_object_unref (info);
g_free (key);
}
else
{
/* Else, make a new request */
request->cache = cache;
/* Transfer ownership of key */
request->key = key;
request->policy = policy;
request->colors = colors ? st_icon_colors_ref (colors) : NULL;
request->icon_info = info;
request->width = request->height = size;
request->scale = scale;
load_texture_async (cache, request);
}
return CLUTTER_ACTOR (texture);
}
示例8: gnibbles_board_load_level
static void
gnibbles_board_load_level (GnibblesBoard *board)
{
gint i,j;
gint x_pos, y_pos;
ClutterActor *tmp;
gboolean is_wall = TRUE;
if (board->level) {
clutter_group_remove_all (CLUTTER_GROUP (board->level));
clutter_container_remove_actor (CLUTTER_CONTAINER (stage), board->level);
}
board->level = clutter_group_new ();
/* Load wall_pixmaps onto the surface*/
for (i = 0; i < BOARDHEIGHT; i++) {
y_pos = i * properties->tilesize;
for (j = 0; j < BOARDWIDTH; j++) {
is_wall = TRUE;
switch (board->walls[j][i]) {
case 'a': // empty space
is_wall = FALSE;
break; // break right away
case 'b': // straight up
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[0]);
break;
case 'c': // straight side
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[1]);
break;
case 'd': // corner bottom left
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[2]);
break;
case 'e': // corner bottom right
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[3]);
break;
case 'f': // corner up left
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[4]);
break;
case 'g': // corner up right
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[5]);
break;
case 'h': // tee up
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[6]);
break;
case 'i': // tee right
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[7]);
break;
case 'j': // tee left
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[8]);
break;
case 'k': // tee down
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[9]);
break;
case 'l': // cross
tmp = gtk_clutter_texture_new_from_pixbuf (wall_pixmaps[10]);
break;
default:
is_wall = FALSE;
break;
}
if (is_wall) {
x_pos = j * properties->tilesize;
clutter_actor_set_size (CLUTTER_ACTOR(tmp),
properties->tilesize,
properties->tilesize);
clutter_actor_set_position (CLUTTER_ACTOR (tmp), x_pos, y_pos);
clutter_actor_show (CLUTTER_ACTOR (tmp));
clutter_container_add_actor (CLUTTER_CONTAINER (board->level),
CLUTTER_ACTOR (tmp));
}
}
}
clutter_container_add_actor (CLUTTER_CONTAINER (stage), board->level);
clutter_actor_raise (board->level, board->surface);
clutter_actor_set_opacity (board->level, 0);
clutter_actor_set_scale (CLUTTER_ACTOR (board->level), 0.2, 0.2);
clutter_actor_animate (board->level, CLUTTER_EASE_OUT_BOUNCE, 1210,
"opacity", 0xff,
"fixed::scale-gravity", CLUTTER_GRAVITY_CENTER,
"scale-x", 1.0,
"scale-y", 1.0,
NULL);
}
示例9: mex_music_player_init
static void
mex_music_player_init (MexMusicPlayer *self)
{
GError *error = NULL;
ClutterActor *box;
MexMusicPlayerPrivate *priv;
ClutterActor *button;
priv = self->priv = MUSIC_PLAYER_PRIVATE (self);
priv->script = clutter_script_new ();
clutter_script_load_from_resource (priv->script,
"/org/media-explorer/MediaExplorer/json/"
"music-player.json",
&error);
if (error)
{
g_error (G_STRLOC " %s", error->message);
g_clear_error (&error);
}
box = mex_script_get_actor (priv->script, "box");
g_assert (box);
clutter_actor_add_child (CLUTTER_ACTOR (self), box);
/* labels */
priv->title_label = mex_script_get_actor (priv->script, "title-label");
priv->subtitle_label = mex_script_get_actor (priv->script, "subtitle-label");
/* play */
priv->play_button = mex_script_get_actor (priv->script, "play-button");
g_signal_connect_swapped (priv->play_button, "clicked",
G_CALLBACK (mex_music_player_play_toggle), self);
/* next */
button = mex_script_get_actor (priv->script, "next-button");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (mex_music_player_next), self);
/* previous */
button = mex_script_get_actor (priv->script, "previous-button");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (mex_music_player_previous), self);
/* stop */
button = mex_script_get_actor (priv->script, "stop-button");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (mex_music_player_quit), self);
/* repeat */
button = mex_script_get_actor (priv->script, "repeat-button");
g_signal_connect_swapped (button, "notify::toggled",
G_CALLBACK (mex_music_player_repeat_toggled), self);
button = mex_script_get_actor (priv->script, "shuffle-button");
g_signal_connect_swapped (button, "notify::toggled",
G_CALLBACK (mex_music_player_shuffle_toggled), self);
/* player */
priv->player = (ClutterMedia *) clutter_gst_video_texture_new ();
g_signal_connect (priv->player, "notify",
G_CALLBACK (mex_music_player_notify_cb), self);
g_signal_connect (priv->player, "eos",
G_CALLBACK (mex_music_player_eos_cb), self);
/* slider */
priv->slider = mex_script_get_actor (priv->script, "progress-slider");
priv->slider_notify_id = g_signal_connect (priv->slider, "notify::value",
G_CALLBACK (mex_music_player_slider_notify),
self);
g_signal_connect (self, "captured-event",
G_CALLBACK (mex_music_player_captured_event), NULL);
}
示例10: clone_source_queue_relayout_cb
static void
clone_source_queue_relayout_cb (ClutterActor *source,
ClutterClone *self)
{
clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
}
示例11: clutter_flow_layout_get_preferred_width
static void
clutter_flow_layout_get_preferred_width (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (manager)->priv;
gint n_rows, line_item_count, line_count;
gfloat total_min_width, total_natural_width;
gfloat line_min_width, line_natural_width;
gfloat max_min_width, max_natural_width;
ClutterActor *actor, *child;
ClutterActorIter iter;
gfloat item_y;
n_rows = get_rows (CLUTTER_FLOW_LAYOUT (manager), for_height);
total_min_width = 0;
total_natural_width = 0;
line_min_width = 0;
line_natural_width = 0;
line_item_count = 0;
line_count = 0;
item_y = 0;
actor = CLUTTER_ACTOR (container);
/* clear the line width arrays */
if (priv->line_min != NULL)
g_array_free (priv->line_min, TRUE);
if (priv->line_natural != NULL)
g_array_free (priv->line_natural, TRUE);
priv->line_min = g_array_sized_new (FALSE, FALSE,
sizeof (gfloat),
16);
priv->line_natural = g_array_sized_new (FALSE, FALSE,
sizeof (gfloat),
16);
if (clutter_actor_get_n_children (actor) != 0)
line_count = 1;
max_min_width = max_natural_width = 0;
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
{
gfloat child_min, child_natural;
gfloat new_y, item_height;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
if (priv->orientation == CLUTTER_FLOW_VERTICAL && for_height > 0)
{
if (line_item_count == n_rows)
{
total_min_width += line_min_width;
total_natural_width += line_natural_width;
g_array_append_val (priv->line_min,
line_min_width);
g_array_append_val (priv->line_natural,
line_natural_width);
line_min_width = line_natural_width = 0;
line_item_count = 0;
line_count += 1;
item_y = 0;
}
new_y = ((line_item_count + 1) * (for_height + priv->row_spacing))
/ n_rows;
item_height = new_y - item_y - priv->row_spacing;
clutter_actor_get_preferred_width (child, item_height,
&child_min,
&child_natural);
line_min_width = MAX (line_min_width, child_min);
line_natural_width = MAX (line_natural_width, child_natural);
item_y = new_y;
line_item_count += 1;
max_min_width = MAX (max_min_width, line_min_width);
max_natural_width = MAX (max_natural_width, line_natural_width);
}
else
{
clutter_actor_get_preferred_width (child, for_height,
&child_min,
&child_natural);
//.........这里部分代码省略.........
示例12: st_container_navigate_focus
static gboolean
st_container_navigate_focus (StWidget *widget,
ClutterActor *from,
GtkDirectionType direction)
{
StContainer *container = ST_CONTAINER (widget);
ClutterActor *container_actor, *focus_child;
GList *children, *l;
container_actor = CLUTTER_ACTOR (widget);
if (from == container_actor)
return FALSE;
/* Figure out if @from is a descendant of @container, and if so,
* set @focus_child to the immediate child of @container that
* contains (or *is*) @from.
*/
focus_child = from;
while (focus_child && clutter_actor_get_parent (focus_child) != container_actor)
focus_child = clutter_actor_get_parent (focus_child);
if (st_widget_get_can_focus (widget))
{
if (!focus_child)
{
/* Accept focus from outside */
clutter_actor_grab_key_focus (container_actor);
return TRUE;
}
else
{
/* Yield focus from within: since @container itself is
* focusable we don't allow the focus to be navigated
* within @container.
*/
return FALSE;
}
}
/* See if we can navigate within @focus_child */
if (focus_child && ST_IS_WIDGET (focus_child))
{
if (st_widget_navigate_focus (ST_WIDGET (focus_child), from, direction, FALSE))
return TRUE;
}
/* At this point we know that we want to navigate focus to one of
* @container's immediate children; the next one after @focus_child,
* or the first one if @focus_child is %NULL. (With "next" and
* "first" being determined by @direction.)
*/
children = st_container_get_focus_chain (container);
if (direction == GTK_DIR_TAB_FORWARD ||
direction == GTK_DIR_TAB_BACKWARD)
{
if (direction == GTK_DIR_TAB_BACKWARD)
children = g_list_reverse (children);
if (focus_child)
{
/* Remove focus_child and any earlier children */
while (children && children->data != focus_child)
children = g_list_delete_link (children, children);
if (children)
children = g_list_delete_link (children, children);
}
}
else /* direction is an arrow key, not tab */
{
StContainerChildSortData sort_data;
/* Compute the allocation box of the previous focused actor, in
* @container's coordinate space. If there was no previous focus,
* use the coordinates of the appropriate edge of @container.
*
* Note that all of this code assumes the actors are not
* transformed (or at most, they are all scaled by the same
* amount). If @container or any of its children is rotated, or
* any child is inconsistently scaled, then the focus chain will
* probably be unpredictable.
*/
if (focus_child)
{
clutter_actor_get_allocation_box (focus_child, &sort_data.box);
}
else
{
clutter_actor_get_allocation_box (CLUTTER_ACTOR (container), &sort_data.box);
switch (direction)
{
case GTK_DIR_UP:
sort_data.box.y1 = sort_data.box.y2;
break;
case GTK_DIR_DOWN:
sort_data.box.y2 = sort_data.box.y1;
break;
case GTK_DIR_LEFT:
sort_data.box.x1 = sort_data.box.x2;
break;
//.........这里部分代码省略.........
示例13: render_logo
static void
render_logo (void)
{
ClutterActor *image;
ClutterActor *text, *text_shadow;
ClutterActor *desc, *desc_shadow;
ClutterColor actor_color = {0xff,0xff,0xff,0xff};
ClutterColor shadow_color = {0x00, 0x00, 0x00, 0x88};
ClutterActor *text_group;
static gint width, height;
gint size;
gfloat stage_w, stage_h;
PangoFontDescription *pfd;
PangoLayout *layout;
PangoContext *context;
gchar *nibbles = _("Nibbles");
/* Translators: This string will be included in the intro screen, so don't make sure it fits! */
gchar *description = _("A worm game for MATE.");
logo = clutter_group_new ();
text_group = clutter_group_new ();
if (!logo_pixmap)
gnibbles_load_logo (properties->tilesize);
image = gtk_clutter_texture_new_from_pixbuf (logo_pixmap);
stage_w = board->width * properties->tilesize;
stage_h = board->height * properties->tilesize;
clutter_actor_set_size (CLUTTER_ACTOR (image), stage_w, stage_h);
clutter_actor_set_position (CLUTTER_ACTOR (image), 0, 0);
clutter_actor_show (image);
text = clutter_text_new ();
clutter_text_set_color (CLUTTER_TEXT (text), &actor_color);
context = gdk_pango_context_get ();
layout = clutter_text_get_layout (CLUTTER_TEXT (text));
pfd = pango_context_get_font_description (context);
size = pango_font_description_get_size (pfd);
pango_font_description_set_size (pfd, (size * stage_w) / 100);
pango_font_description_set_family (pfd, "Sans");
pango_font_description_set_weight(pfd, PANGO_WEIGHT_BOLD);
pango_layout_set_font_description (layout, pfd);
pango_layout_set_text (layout, nibbles, -1);
pango_layout_get_pixel_size (layout, &width, &height);
text_shadow = clutter_text_new ();
clutter_text_set_color (CLUTTER_TEXT (text_shadow), &shadow_color);
layout = clutter_text_get_layout (CLUTTER_TEXT (text_shadow));
pango_layout_set_font_description (layout, pfd);
pango_layout_set_text (layout, nibbles, -1);
clutter_actor_set_position (CLUTTER_ACTOR (text),
(stage_w - width) * 0.5 ,
stage_h * .72);
clutter_actor_set_position (CLUTTER_ACTOR (text_shadow),
(stage_w - width) * 0.5 + 5,
stage_h * .72 + 5);
desc = clutter_text_new ();
layout = clutter_text_get_layout (CLUTTER_TEXT (desc));
clutter_text_set_color (CLUTTER_TEXT (desc), &actor_color);
pango_font_description_set_size (pfd, (size * stage_w) / 400);
pango_layout_set_font_description (layout, pfd);
pango_layout_set_text (layout, description, -1);
pango_layout_get_pixel_size(layout, &width, &height);
desc_shadow = clutter_text_new ();
layout = clutter_text_get_layout (CLUTTER_TEXT (desc_shadow));
clutter_text_set_color (CLUTTER_TEXT (desc_shadow), &shadow_color);
pango_font_description_set_size (pfd, (size * stage_w) / 400);
pango_layout_set_font_description (layout, pfd);
pango_layout_set_text (layout, description, -1);
clutter_actor_set_position (CLUTTER_ACTOR (desc),
(stage_w - width) * 0.5,
stage_h* .93);
clutter_actor_set_position (CLUTTER_ACTOR (desc_shadow),
(stage_w - width) * 0.5 + 3,
stage_h * .93 + 3);
clutter_container_add (CLUTTER_CONTAINER (text_group),
CLUTTER_ACTOR (text_shadow),
CLUTTER_ACTOR (text),
CLUTTER_ACTOR (desc_shadow),
CLUTTER_ACTOR (desc),
NULL);
clutter_container_add (CLUTTER_CONTAINER (logo),
CLUTTER_ACTOR (image),
CLUTTER_ACTOR (text_group),
NULL);
//.........这里部分代码省略.........
示例14: _xfdashboard_text_box_get_preferred_width
static void _xfdashboard_text_box_get_preferred_width(ClutterActor *self,
gfloat inForHeight,
gfloat *outMinWidth,
gfloat *outNaturalWidth)
{
XfdashboardTextBoxPrivate *priv=XFDASHBOARD_TEXT_BOX(self)->priv;
gfloat minWidth, naturalWidth;
gfloat childMinWidth, childNaturalWidth;
gint numberChildren=0;
minWidth=naturalWidth=0.0f;
/* Determine size of primary icon if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorPrimaryIcon))
{
clutter_actor_get_preferred_width(CLUTTER_ACTOR(priv->actorPrimaryIcon),
inForHeight,
&childMinWidth, &childNaturalWidth);
minWidth+=childMinWidth;
naturalWidth+=childNaturalWidth;
numberChildren++;
}
/* Determine size of editable text box if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorTextBox))
{
clutter_actor_get_preferred_width(CLUTTER_ACTOR(priv->actorTextBox),
inForHeight,
&childMinWidth, &childNaturalWidth);
minWidth+=childMinWidth;
naturalWidth+=childNaturalWidth;
numberChildren++;
}
/* Determine size of hint label if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorHintLabel))
{
clutter_actor_get_preferred_width(CLUTTER_ACTOR(priv->actorHintLabel),
inForHeight,
&childMinWidth, &childNaturalWidth);
minWidth+=childMinWidth;
naturalWidth+=childNaturalWidth;
numberChildren++;
}
/* Determine size of secondary icon if visible */
if(CLUTTER_ACTOR_IS_VISIBLE(priv->actorSecondaryIcon))
{
clutter_actor_get_preferred_width(CLUTTER_ACTOR(priv->actorSecondaryIcon),
inForHeight,
&childMinWidth, &childNaturalWidth);
minWidth+=childMinWidth;
naturalWidth+=childNaturalWidth;
}
/* Add spacing for each child except the last one */
if(numberChildren>1)
{
numberChildren--;
minWidth+=(numberChildren*priv->spacing);
naturalWidth+=(numberChildren*priv->spacing);
}
// Add padding
minWidth+=2*priv->padding;
naturalWidth+=2*priv->padding;
/* Store sizes computed */
if(outMinWidth) *outMinWidth=minWidth;
if(outNaturalWidth) *outNaturalWidth=naturalWidth;
}
示例15: create_map_window
static void
create_map_window (GourmapUi *ui)
{
GourmapUiPrivate *priv;
GtkWidget *hbox;
GtkWidget *vbox1, *vbox2;
GtkWidget *toolbar;
GtkWidget *addr_label;
GtkToolItem *item;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *select;
priv = GET_PRIVATE (ui);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
/* map */
priv->map = gtk_champlain_embed_new ();
priv->champ_view = gtk_champlain_embed_get_view (GTK_CHAMPLAIN_EMBED (priv->map));
clutter_actor_set_reactive (CLUTTER_ACTOR (priv->champ_view), TRUE);
g_object_set (G_OBJECT (priv->champ_view),
"kinetic-mode", TRUE,
NULL);
priv->marker_layer = champlain_marker_layer_new_full (CHAMPLAIN_SELECTION_SINGLE);
champlain_view_add_layer (priv->champ_view, CHAMPLAIN_LAYER (priv->marker_layer));
/* sidebar */
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
/* restaurant list */
priv->store = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_UINT);
priv->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->store));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Restaurant List"),
renderer,
"text", NAME_COLUMN,
NULL);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (select), "changed",
G_CALLBACK (tree_selection_changed_cb),
(gpointer) ui);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column);
gtk_box_pack_start (GTK_BOX (vbox2), priv->treeview, TRUE, TRUE, 0);
/* random button */
priv->rand_button = gtk_button_new_with_label (_("Random Selection!"));
g_signal_connect (G_OBJECT (priv->rand_button),
"clicked",
G_CALLBACK (random_button_cb),
(gpointer) ui);
gtk_box_pack_start (GTK_BOX (vbox2), priv->rand_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), priv->map, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);
/* address */
toolbar = gtk_toolbar_new ();
item = gtk_tool_item_new ();
addr_label = gtk_label_new (_("Address"));
gtk_container_add (GTK_CONTAINER (item), addr_label);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_item_new ();
gtk_tool_item_set_expand (item, TRUE);
priv->addr_entry = gtk_entry_new ();
gtk_container_add (GTK_CONTAINER (item), priv->addr_entry);
g_signal_connect (G_OBJECT (priv->addr_entry),
"activate",
G_CALLBACK (activate_addr_entry_cb),
(gpointer) ui);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new_from_stock (GTK_STOCK_OK);
g_signal_connect (G_OBJECT (item),
"clicked",
G_CALLBACK (activate_addr_entry_cb),
(gpointer) ui);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox1), toolbar, FALSE, FALSE, 0);
/* main window */
priv->main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (priv->main_window), 1024, 768);
gtk_widget_set_name (priv->main_window, _("Gourmap"));
g_signal_connect (G_OBJECT (priv->main_window),
"destroy",
G_CALLBACK (destroy_cb),
NULL);
gtk_container_add (GTK_CONTAINER (priv->main_window), vbox1);
}