static gint
sort_box_children (GtkWidget * widget_a, GtkWidget * widget_b, GtkWidget *box)
{
GladeWidget *gwidget_a, *gwidget_b;
gint position_a, position_b;
gwidget_a = glade_widget_get_from_gobject (widget_a);
gwidget_b = glade_widget_get_from_gobject (widget_b);
/* Indirect children might be internal children, sort internal children before any other children */
if (box != gtk_widget_get_parent (widget_a))
return -1;
if (box != gtk_widget_get_parent (widget_b))
return 1;
if (gtk_box_get_center_widget (GTK_BOX (box)) == widget_a)
return -1;
if (gtk_box_get_center_widget (GTK_BOX (box)) == widget_b)
return -1;
/* XXX Sometimes the packing "position" property doesnt exist here, why ?
*/
if (gwidget_a)
glade_widget_pack_property_get (gwidget_a, "position", &position_a);
else
gtk_container_child_get (GTK_CONTAINER (box),
widget_a, "position", &position_a, NULL);
if (gwidget_b)
glade_widget_pack_property_get (gwidget_b, "position", &position_b);
else
gtk_container_child_get (GTK_CONTAINER (box),
widget_b, "position", &position_b, NULL);
return position_a - position_b;
}
static void
bond_private_init (CEPageBond *self)
{
CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);
GtkBuilder *builder;
builder = CE_PAGE (self)->builder;
priv->mode = GTK_COMBO_BOX (gtk_builder_get_object (builder, "bond_mode"));
priv->monitoring = GTK_COMBO_BOX (gtk_builder_get_object (builder, "bond_monitoring"));
priv->frequency = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "bond_frequency"));
priv->updelay = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "bond_updelay"));
priv->updelay_label = GTK_WIDGET (gtk_builder_get_object (builder, "bond_updelay_label"));
priv->updelay_box = GTK_WIDGET (gtk_builder_get_object (builder, "bond_updelay_box"));
priv->downdelay = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "bond_downdelay"));
priv->downdelay_label = GTK_WIDGET (gtk_builder_get_object (builder, "bond_downdelay_label"));
priv->downdelay_box = GTK_WIDGET (gtk_builder_get_object (builder, "bond_downdelay_box"));
priv->arp_targets = GTK_ENTRY (gtk_builder_get_object (builder, "bond_arp_targets"));
priv->arp_targets_label = GTK_WIDGET (gtk_builder_get_object (builder, "bond_arp_targets_label"));
priv->toplevel = GTK_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (priv->mode),
GTK_TYPE_WINDOW));
priv->table = GTK_TABLE (gtk_builder_get_object (builder, "BondPage"));
priv->table_row_spacing = gtk_table_get_default_row_spacing (priv->table);
gtk_container_child_get (GTK_CONTAINER (priv->table), priv->updelay_label,
"top-attach", &priv->updelay_row,
NULL);
gtk_container_child_get (GTK_CONTAINER (priv->table), priv->downdelay_label,
"top-attach", &priv->downdelay_row,
NULL);
gtk_container_child_get (GTK_CONTAINER (priv->table), priv->arp_targets_label,
"top-attach", &priv->arp_targets_row,
NULL);
}
static gint
sort_children (GtkWidget * widget_a, GtkWidget * widget_b, GtkWidget *box)
{
GladeWidget *gwidget_a, *gwidget_b;
gint position_a, position_b;
gwidget_a = glade_widget_get_from_gobject (widget_a);
gwidget_b = glade_widget_get_from_gobject (widget_b);
/* Sort internal children before any other children */
if (box != gtk_widget_get_parent (widget_a))
return -1;
if (box != gtk_widget_get_parent (widget_b))
return 1;
if (gtk_action_bar_get_center_widget (GTK_ACTION_BAR (box)) == widget_a)
return -1;
if (gtk_action_bar_get_center_widget (GTK_ACTION_BAR (box)) == widget_b)
return -1;
if (gwidget_a)
glade_widget_pack_property_get (gwidget_a, "position", &position_a);
else
gtk_container_child_get (GTK_CONTAINER (box),
widget_a, "position", &position_a, NULL);
if (gwidget_b)
glade_widget_pack_property_get (gwidget_b, "position", &position_b);
else
gtk_container_child_get (GTK_CONTAINER (box),
widget_b, "position", &position_b, NULL);
return position_a - position_b;
}
void
contacts_remove_field_cb (GtkWidget *button, gpointer data)
{
GtkWidget *window = gtk_widget_get_toplevel (button);
GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW (window));
GtkWidget *ancestor = gtk_widget_get_ancestor (
widget, GTK_TYPE_EXPANDER);
gtk_window_set_focus (GTK_WINDOW (window), NULL);
if (ancestor) {
contacts_remove_entries (ancestor);
return;
}
ancestor = gtk_widget_get_ancestor (widget, GTK_TYPE_COMBO_BOX_ENTRY);
if (ancestor) {
const gchar *name;
guint top, left;
GtkWidget *table;
GList *c, *children;
ancestor = gtk_widget_get_ancestor (
ancestor, GTK_TYPE_EVENT_BOX);
name = gtk_widget_get_name (ancestor);
table = gtk_widget_get_ancestor (ancestor, GTK_TYPE_TABLE);
gtk_container_child_get (GTK_CONTAINER (table),
ancestor, "left-attach", &left,
"top-attach", &top, NULL);
children = gtk_container_get_children (GTK_CONTAINER (table));
for (c = children; c; c = c->next) {
guint ctop, cleft;
gtk_container_child_get (GTK_CONTAINER (table),
GTK_WIDGET (c->data),
"left-attach", &cleft,
"top-attach", &ctop, NULL);
if ((cleft == left+1) && (ctop == top)) {
contacts_remove_entries (GTK_WIDGET (c->data));
break;
}
}
g_list_free (c);
return;
}
contacts_remove_entries (widget);
}
static void
update_button (GtkStackSwitcher *self,
GtkWidget *widget,
GtkWidget *button)
{
gchar *title;
gchar *icon_name;
gtk_container_child_get (GTK_CONTAINER (self->priv->stack), widget,
"title", &title,
"icon-name", &icon_name,
NULL);
rebuild_child (button, icon_name, title);
gtk_widget_set_visible (button, title != NULL || icon_name != NULL);
if (icon_name != NULL)
gtk_widget_set_size_request (button, -1, -1);
else
gtk_widget_set_size_request (button, 100, -1);
g_free (title);
g_free (icon_name);
}
static void
create_widgets (GtkActionBar *bar,
GtkPackType pack_type,
gint n)
{
GList *children, *l;
GtkWidget *child;
gint i;
gchar *label;
children = gtk_container_get_children (GTK_CONTAINER (bar));
for (l = children; l; l = l->next)
{
GtkPackType type;
child = l->data;
gtk_container_child_get (GTK_CONTAINER (bar), child, "pack-type", &type, NULL);
if (type == pack_type)
gtk_container_remove (GTK_CONTAINER (bar), child);
}
g_list_free (children);
for (i = 0; i < n; i++)
{
label = g_strdup_printf ("%d", i);
child = gtk_button_new_with_label (label);
g_free (label);
gtk_widget_show (child);
if (pack_type == GTK_PACK_START)
gtk_action_bar_pack_start (bar, child);
else
gtk_action_bar_pack_end (bar, child);
}
}
static void
_rows_reordered_cb (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer user_data)
{
CarrickList *list = user_data;
CarrickListPrivate *priv = list->priv;
GtkWidget *item = NULL;
DBusGProxy *proxy = NULL;
guint order, index;
if (!iter)
return;
gtk_tree_model_get (tree_model, iter,
CARRICK_COLUMN_PROXY, &proxy,
CARRICK_COLUMN_INDEX, &index,
-1);
/* Find widget for changed row, tell it to refresh
* variables and update */
item = carrick_list_find_service_item (list,
proxy);
/* Check the order and, where neccesarry, reorder */
gtk_container_child_get (GTK_CONTAINER (priv->box),
item,
"position", &order,
NULL);
if (order != index)
gtk_box_reorder_child (GTK_BOX (priv->box),
item,
index);
}
static gint
grid_get_height (GtkWidget *grid)
{
GList *children;
GList *child;
gint height = 0;
gint top_attach = 0;
gint max = 0;
children = gtk_container_get_children (GTK_CONTAINER (grid));
for (child = children; child; child = g_list_next (child))
{
gtk_container_child_get (GTK_CONTAINER (grid), child->data,
"top-attach", &top_attach,
"height", &height,
NULL);
if (height + top_attach > max)
max = height + top_attach;
}
g_list_free (children);
return max;
}
void
toggle_shrink (GtkWidget *widget,
GtkWidget *child)
{
GtkWidget *parent;
GtkPaned *paned;
gboolean is_child1;
gboolean resize, shrink;
parent = gtk_widget_get_parent (child);
paned = GTK_PANED (parent);
is_child1 = (child == gtk_paned_get_child1 (paned));
gtk_container_child_get (GTK_CONTAINER (paned), child,
"resize", &resize,
"shrink", &shrink,
NULL);
g_object_ref (child);
gtk_container_remove (GTK_CONTAINER (parent), child);
if (is_child1)
gtk_paned_pack1 (paned, child, resize, !shrink);
else
gtk_paned_pack2 (paned, child, resize, !shrink);
g_object_unref (child);
}
static void
ide_frame_change_current_page (IdeFrame *self,
gint direction)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
g_autoptr(GPtrArray) ar = NULL;
GtkWidget *visible_child;
gint position = 0;
g_assert (IDE_IS_FRAME (self));
visible_child = gtk_stack_get_visible_child (priv->stack);
if (visible_child == NULL)
return;
gtk_container_child_get (GTK_CONTAINER (priv->stack), visible_child,
"position", &position,
NULL);
ar = g_ptr_array_new ();
gtk_container_foreach (GTK_CONTAINER (priv->stack), collect_widgets, ar);
if (ar->len == 0)
g_return_if_reached ();
visible_child = g_ptr_array_index (ar, (position + direction) % ar->len);
gtk_stack_set_visible_child (priv->stack, visible_child);
}
static void
gb_shortcuts_dialog__stack__notify_visible_child (GbShortcutsDialog *self,
GParamSpec *pspec,
GtkStack *stack)
{
GbShortcutsDialogPrivate *priv = gb_shortcuts_dialog_get_instance_private (self);
GtkWidget *visible_child;
visible_child = gtk_stack_get_visible_child (stack);
if (GB_IS_SHORTCUTS_VIEW (visible_child))
{
const gchar *title;
title = gb_shortcuts_view_get_title (GB_SHORTCUTS_VIEW (visible_child));
gtk_label_set_label (priv->menu_label, title);
}
else if (visible_child != NULL)
{
g_autofree gchar *title = NULL;
gtk_container_child_get (GTK_CONTAINER (stack), visible_child,
"title", &title,
NULL);
gtk_label_set_label (priv->menu_label, title);
}
}
static void
carrick_list_drag_begin (GtkWidget *widget,
GdkDragContext *context,
CarrickList *list)
{
CarrickListPrivate *priv = list->priv;
gint x, y;
carrick_service_item_set_active (CARRICK_SERVICE_ITEM (widget), FALSE);
/* save old place in list for drag-failures */
gtk_container_child_get (GTK_CONTAINER (priv->box),
widget,
"position", &priv->drag_position,
NULL);
priv->drop_position = priv->drag_position;
/* remove widget from list and setup dnd popup window */
priv->drag_window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_size_request (priv->drag_window,
widget->allocation.width,
widget->allocation.height);
gtk_widget_get_pointer (widget, &x, &y);
gtk_widget_reparent (widget, priv->drag_window);
gtk_drag_set_icon_widget (context,
priv->drag_window,
x, y);
}
static void
pnl_tab_strip_child_title_changed (PnlTabStrip *self,
GParamSpec *pspec,
GtkWidget *child)
{
g_autofree gchar *title = NULL;
GtkWidget *parent;
PnlTab *tab;
g_assert (PNL_IS_TAB_STRIP (self));
g_assert (GTK_IS_WIDGET (child));
tab = g_object_get_data (G_OBJECT (child), "PNL_TAB");
if (!PNL_IS_TAB (tab))
return;
parent = gtk_widget_get_parent (child);
gtk_container_child_get (GTK_CONTAINER (parent), child,
"title", &title,
NULL);
pnl_tab_set_title (tab, title);
}
static void
pnl_tab_strip_child_position_changed (PnlTabStrip *self,
GParamSpec *pspec,
GtkWidget *child)
{
GVariant *state;
GtkWidget *parent;
PnlTab *tab;
guint position;
g_assert (PNL_IS_TAB_STRIP (self));
g_assert (GTK_IS_WIDGET (child));
tab = g_object_get_data (G_OBJECT (child), "PNL_TAB");
if (!tab || !PNL_IS_TAB (tab))
return;
parent = gtk_widget_get_parent (child);
gtk_container_child_get (GTK_CONTAINER (parent), child,
"position", &position,
NULL);
gtk_container_child_set (GTK_CONTAINER (self), GTK_WIDGET (tab),
"position", position,
NULL);
state = g_variant_new_int32 (position);
gtk_actionable_set_action_target_value (GTK_ACTIONABLE (tab), state);
}
static void
gb_shortcuts_dialog_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GbShortcutsDialog *self = (GbShortcutsDialog *)object;
GbShortcutsDialogPrivate *priv = gb_shortcuts_dialog_get_instance_private (self);
switch (prop_id)
{
case PROP_VIEW_NAME:
{
GtkWidget *child = gtk_stack_get_visible_child (priv->stack);
if (child != NULL)
{
gchar *name = NULL;
gtk_container_child_get (GTK_CONTAINER (priv->stack), child,
"name", &name,
NULL);
g_value_take_string (value, name);
}
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
/** This function moves a GtkWidget from one GtkTable to another,
* preserving its attachment data, etc. It is called when adding one
* partial preference page to another.
*
* @internal
*
* @param widget A pointer to the widget to move.
*
* @param data A pointer to a data structure passed in by the caller.
* This data structure contains pointers to the old and new tables,
* plus the row offset into the new table.
*/
static void
gnc_prefs_move_table_entry (GtkWidget *child,
gpointer data)
{
struct copy_data *copydata = data;
GtkAttachOptions x_opts, y_opts;
gint bottom, top, left, right, x_pad, y_pad;
ENTER("child %p, copy data %p", child, data);
gtk_container_child_get(GTK_CONTAINER(copydata->table_from), child,
"bottom-attach", &bottom,
"left-attach", &left,
"right-attach", &right,
"top-attach", &top,
"x-options", &x_opts,
"x-padding", &x_pad,
"y-options", &y_opts,
"y-padding", &y_pad,
NULL);
g_object_ref(child);
gtk_container_remove(GTK_CONTAINER(copydata->table_from), child);
gtk_table_attach(copydata->table_to, child, left, right,
top + copydata->row_offset, bottom + copydata->row_offset,
x_opts, y_opts, x_pad, y_pad);
g_object_unref(child);
LEAVE(" ");
}
void
ide_workbench_add_perspective (IdeWorkbench *self,
IdePerspective *perspective)
{
g_autofree gchar *accel= NULL;
g_autofree gchar *icon_name = NULL;
g_autofree gchar *id = NULL;
g_autofree gchar *title = NULL;
GtkWidget *titlebar;
g_assert (IDE_IS_WORKBENCH (self));
g_assert (IDE_IS_PERSPECTIVE (perspective));
id = ide_perspective_get_id (perspective);
title = ide_perspective_get_title (perspective);
icon_name = ide_perspective_get_icon_name (perspective);
titlebar = ide_perspective_get_titlebar (perspective);
gtk_container_add_with_properties (GTK_CONTAINER (self->perspectives_stack),
GTK_WIDGET (perspective),
"icon-name", icon_name,
"name", id,
"needs-attention", FALSE,
"title", title,
NULL);
if (titlebar != NULL)
gtk_container_add_with_properties (GTK_CONTAINER (self->header_stack), titlebar,
"name", id,
NULL);
if (!IDE_IS_GREETER_PERSPECTIVE (perspective))
{
guint position = 0;
gtk_container_child_get (GTK_CONTAINER (self->perspectives_stack),
GTK_WIDGET (perspective),
"position", &position,
NULL);
g_list_store_append (self->perspectives, perspective);
g_list_store_sort (self->perspectives,
ide_workbench_compare_perspective,
NULL);
}
accel = ide_perspective_get_accelerator (perspective);
if (accel != NULL)
{
const gchar *accel_map[] = { accel, NULL };
g_autofree gchar *action_name = NULL;
action_name = g_strdup_printf ("win.perspective('%s')", id);
gtk_application_set_accels_for_action (GTK_APPLICATION (IDE_APPLICATION_DEFAULT),
action_name, accel_map);
}
}
void
go_gtk_widget_replace (GtkWidget *victim, GtkWidget *replacement)
{
GtkContainer *parent = GTK_CONTAINER (gtk_widget_get_parent (victim));
if (GTK_IS_GRID (parent)) {
int col, row, width, height;
gtk_container_child_get (parent,
victim,
"left-attach", &col,
"top-attach", &row,
"width", &width,
"height", &height,
NULL);
gtk_container_remove (parent, victim);
gtk_grid_attach (GTK_GRID (parent), replacement,
col, row, width, height);
} else if (GTK_IS_BOX (parent)) {
GtkBox *box = GTK_BOX (parent);
gboolean expand, fill;
guint padding;
GtkPackType pack_type;
int pos;
gtk_box_query_child_packing (box, victim,
&expand, &fill,
&padding, &pack_type);
gtk_container_child_get (parent, victim,
"position", &pos,
NULL);
gtk_container_remove (parent, victim);
gtk_container_add (parent, replacement);
gtk_box_set_child_packing (box, replacement,
expand, fill,
padding, pack_type);
gtk_box_reorder_child (box, replacement, pos);
} else {
g_error ("Unsupported container: %s",
g_type_name_from_instance ((gpointer)parent));
}
}
static void
glade_gtk_grid_get_child_attachments (GtkWidget *grid,
GtkWidget *child,
GladeGridAttachments *grid_child)
{
gtk_container_child_get (GTK_CONTAINER (grid), child,
"left-attach", &grid_child->left_attach,
"width", &grid_child->width,
"top-attach", &grid_child->top_attach,
"height", &grid_child->height,
NULL);
}
static void
ViewOvBoxGetOverGeometry(ViewOvBox *that, // IN
int *x, // OUT
int *y, // OUT
int *width, // OUT
int *height) // OUT
{
ViewOvBoxPrivate *priv;
gboolean expand;
gboolean fill;
guint padding;
unsigned int boxWidth;
GtkAllocation allocation;
priv = that->priv;
if (priv->over) {
/*
* When a child's expand or fill property changes, GtkBox queues
* a resize for the child.
*/
gtk_container_child_get(GTK_CONTAINER(that), priv->over,
"expand", &expand,
"fill", &fill,
"padding", &padding,
NULL);
} else {
/* Default values used by GtkBox. */
expand = TRUE;
fill = TRUE;
padding = 0;
}
gtk_widget_get_allocation(GTK_WIDGET(that), &allocation);
boxWidth = allocation.width;
if (!expand) {
*width = MIN(priv->overR.width, boxWidth - padding);
*x = padding;
} else if (!fill) {
*width = MIN(priv->overR.width, boxWidth);
*x = (boxWidth - *width) / 2;
} else {
*width = boxWidth;
*x = 0;
}
*y = (priv->overR.height - ViewOvBoxGetActualMin(that))
* (priv->fraction - 1) + priv->verticalOffset;
*height = priv->overR.height;
}
static void
set_tab_state (GSimpleAction *action,
GVariant *state,
gpointer user_data)
{
PnlTabStrip *self = user_data;
PnlTabStripPrivate *priv = pnl_tab_strip_get_instance_private (self);
PnlTab *tab = NULL;
const GList *iter;
GList *list;
gint stateval;
g_assert (G_IS_SIMPLE_ACTION (action));
g_assert (PNL_IS_TAB_STRIP (self));
g_assert (state != NULL);
g_assert (g_variant_is_of_type (state, G_VARIANT_TYPE_INT32));
g_simple_action_set_state (action, state);
stateval = g_variant_get_int32 (state);
list = gtk_container_get_children (GTK_CONTAINER (priv->stack));
for (iter = list; iter != NULL; iter = iter->next)
{
GtkWidget *child = iter->data;
gint position = 0;
gtk_container_child_get (GTK_CONTAINER (priv->stack), GTK_WIDGET (child),
"position", &position,
NULL);
if (position == stateval)
{
tab = g_object_get_data (G_OBJECT (child), "PNL_TAB");
gtk_stack_set_visible_child (priv->stack, child);
break;
}
}
/*
* When clicking an active toggle button, we get the state callback but then
* the toggle button disables the checked state. So ensure it stays on by
* manually setting the state.
*/
if (PNL_IS_TAB (tab))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tab), TRUE);
g_list_free (list);
}
/**
* gimp_resolution_entry_attach_label:
* @gre: The #GimpResolutionEntry you want to add a label to.
* @text: The text of the label.
* @row: The row where the label will be attached.
* @column: The column where the label will be attached.
* @alignment: The horizontal alignment of the label.
*
* Attaches a #GtkLabel to the #GimpResolutionEntry (which is a #GtkTable).
*
* Returns: A pointer to the new #GtkLabel widget.
**/
GtkWidget *
gimp_resolution_entry_attach_label (GimpResolutionEntry *gre,
const gchar *text,
gint row,
gint column,
gfloat alignment)
{
GtkWidget *label;
g_return_val_if_fail (GIMP_IS_RESOLUTION_ENTRY (gre), NULL);
g_return_val_if_fail (text != NULL, NULL);
label = gtk_label_new_with_mnemonic (text);
if (column == 0)
{
GList *children;
GList *list;
children = gtk_container_get_children (GTK_CONTAINER (gre));
for (list = children; list; list = g_list_next (list))
{
GtkWidget *child = list->data;
gint left_attach;
gint top_attach;
gtk_container_child_get (GTK_CONTAINER (gre), child,
"left-attach", &left_attach,
"top-attach", &top_attach,
NULL);
if (left_attach == 1 && top_attach == row)
{
gtk_label_set_mnemonic_widget (GTK_LABEL (label), child);
break;
}
}
g_list_free (children);
}
gtk_misc_set_alignment (GTK_MISC (label), alignment, 0.5);
gtk_table_attach (GTK_TABLE (gre), label, column, column+1, row, row+1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
return label;
}
static void
update_position (GtkWidget *widget, gpointer data)
{
GtkContainer *parent = data;
GladeWidget *gwidget;
gint position;
gwidget = glade_widget_get_from_gobject (widget);
if (gwidget)
{
gtk_container_child_get (parent, widget, "position", &position, NULL);
glade_widget_pack_property_set (gwidget, "position", position);
}
}
static void
pnl_tab_strip_stack_add (PnlTabStrip *self,
GtkWidget *widget,
GtkStack *stack)
{
PnlTabStripPrivate *priv = pnl_tab_strip_get_instance_private (self);
GVariant *target;
PnlTab *tab;
gint position = 0;
g_assert (PNL_IS_TAB_STRIP (self));
g_assert (GTK_IS_WIDGET (widget));
g_assert (GTK_IS_STACK (stack));
gtk_container_child_get (GTK_CONTAINER (stack), widget,
"position", &position,
NULL);
target = g_variant_new_int32 (position);
tab = g_object_new (PNL_TYPE_TAB,
"action-name", "tab-strip.tab",
"action-target", target,
"edge", priv->edge,
"widget", widget,
NULL);
g_object_set_data (G_OBJECT (widget), "PNL_TAB", tab);
g_signal_connect_object (widget,
"child-notify::position",
G_CALLBACK (pnl_tab_strip_child_position_changed),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (widget,
"child-notify::title",
G_CALLBACK (pnl_tab_strip_child_title_changed),
self,
G_CONNECT_SWAPPED);
gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (tab));
g_object_bind_property (widget, "visible", tab, "visible", G_BINDING_SYNC_CREATE);
pnl_tab_strip_child_title_changed (self, NULL, widget);
pnl_tab_strip_stack_notify_visible_child (self, NULL, stack);
}
static void
on_position_updated (GtkWidget *widget,
GParamSpec *pspec,
GtkStackSwitcher *self)
{
GtkWidget *button;
gint position;
button = g_hash_table_lookup (self->priv->buttons, widget);
gtk_container_child_get (GTK_CONTAINER (self->priv->stack), widget,
"position", &position,
NULL);
gtk_box_reorder_child (GTK_BOX (self), button, position);
}
static gchar *
ev_sidebar_get_visible_icon_name (EvSidebar *ev_sidebar)
{
GtkStack *stack;
GtkWidget *widget;
gchar *icon_name;
EvSidebarPrivate *priv = GET_PRIVATE (ev_sidebar);
stack = GTK_STACK (priv->stack);
widget = gtk_stack_get_visible_child (stack);
gtk_container_child_get (GTK_CONTAINER (stack), widget,
"icon-name", &icon_name,
NULL);
return icon_name;
}
/* Outputs source to add a child widget to a GtkFixed. */
static void
gb_fixed_write_add_child_source (GtkWidget * parent,
const gchar *parent_name,
GtkWidget *child,
GbWidgetWriteSourceData * data)
{
gint x, y;
gtk_container_child_get (GTK_CONTAINER (parent), child,
"x", &x,
"y", &y,
NULL);
source_add (data,
" gtk_fixed_put (GTK_FIXED (%s), %s, %i, %i);\n",
parent_name, data->wname, x, y);
}
static gboolean
carrick_list_drag_drop (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time,
CarrickList *list)
{
CarrickListPrivate *priv = list->priv;
gtk_container_child_get (GTK_CONTAINER (priv->box),
widget,
"position", &priv->drop_position,
NULL);
gtk_drag_finish (context, TRUE, TRUE, time);
return TRUE;
}
static void _move_close_button_for(DeepinWorkspaceOverview* self,
MetaDeepinClonedWidget* cloned)
{
GtkAllocation alloc;
gtk_widget_get_allocation(GTK_WIDGET(cloned), &alloc);
gint x = 0, y = 0;
gtk_container_child_get(GTK_CONTAINER(self), GTK_WIDGET(cloned),
"x", &x, "y", &y, NULL);
gdouble sx = 1.0;
meta_deepin_cloned_widget_get_scale(cloned, &sx, NULL);
deepin_fixed_move(DEEPIN_FIXED(self), self->priv->close_button,
x + alloc.width * sx /2,
y - alloc.height * sx /2,
FALSE);
}
/** This function finds the size of a GtkGrid and saves it to
* the data structure.
*
* @internal
*
* @param widget A pointer to the widget to move.
*
* @param data A pointer to a data structure passed in by the caller.
* This data structure contains pointers to the old and new grids
* plus the row offset into the new grid.
*/
static void
gnc_prefs_get_grid_size (GtkWidget *child, gpointer data)
{
struct copy_data *copydata = data;
gint top, left, height, width;
gtk_container_child_get(GTK_CONTAINER(copydata->grid_to), child,
"left-attach", &left,
"top-attach", &top,
"height", &height,
"width", &width,
NULL);
if (left + width >= copydata->cols)
copydata->cols = left + width;
if (top + height >= copydata->rows)
copydata->rows = top + height;
}
