static void
glade_gtk_header_bar_set_size (GObject * object,
const GValue * value)
{
GList *l, *next, *children;
GtkWidget *child;
guint new_size, old_size, i;
g_return_if_fail (GTK_IS_HEADER_BAR (object));
d(g_message ("Setting size to %d", g_value_get_int (value)));
if (glade_util_object_is_loading (object))
return;
children = gtk_container_get_children (GTK_CONTAINER (object));
l = children;
while (l)
{
next = l->next;
if (l->data == gtk_header_bar_get_custom_title (GTK_HEADER_BAR (object)) ||
(!glade_widget_get_from_gobject (l->data) && !GLADE_IS_PLACEHOLDER (l->data)))
children = g_list_delete_link (children, l);
l = next;
}
old_size = g_list_length (children);
new_size = g_value_get_int (value);
if (old_size == new_size)
{
g_list_free (children);
return;
}
for (i = old_size; i < new_size; i++)
{
GtkWidget *placeholder = glade_placeholder_new ();
gtk_header_bar_pack_start (GTK_HEADER_BAR (object), placeholder);
}
for (l = g_list_last (children); l && old_size > new_size; l = l->prev)
{
child = l->data;
if (glade_widget_get_from_gobject (child) || !GLADE_IS_PLACEHOLDER (child))
continue;
gtk_container_remove (GTK_CONTAINER (object), child);
old_size--;
}
g_list_free (children);
}
void
glade_gtk_action_bar_add_child (GladeWidgetAdaptor * adaptor,
GObject * object,
GObject * child)
{
GladeWidget *gbox, *gchild;
gint num_children;
gchar *special_child_type;
gbox = glade_widget_get_from_gobject (object);
special_child_type = g_object_get_data (child, "special-child-type");
if (special_child_type && !strcmp (special_child_type, "center"))
{
gtk_action_bar_set_center_widget (GTK_ACTION_BAR (object), GTK_WIDGET (child));
return;
}
/*
Try to remove the last placeholder if any, this way GtkBox`s size
will not be changed.
*/
if (!glade_widget_superuser () && !GLADE_IS_PLACEHOLDER (child))
{
GList *l, *children;
children = gtk_container_get_children (GTK_CONTAINER (object));
for (l = g_list_last (children); l; l = g_list_previous (l))
{
GtkWidget *child_widget = l->data;
if (GLADE_IS_PLACEHOLDER (child_widget))
{
gtk_container_remove (GTK_CONTAINER (object), child_widget);
break;
}
}
g_list_free (children);
}
gtk_container_add (GTK_CONTAINER (object), GTK_WIDGET (child));
num_children = glade_gtk_action_bar_get_num_children (object);
glade_widget_property_set (gbox, "size", num_children);
if (glade_widget_superuser ())
return;
gchild = glade_widget_get_from_gobject (child);
/* Packing props arent around when parenting during a glade_widget_dup() */
if (gchild && glade_widget_get_packing_properties (gchild))
glade_widget_pack_property_set (gchild, "position", num_children - 1);
}
void
glade_popup_placeholder_pop (GladePlaceholder *placeholder,
GdkEventButton *event)
{
GladeWidget *widget;
GtkWidget *popup_menu;
gint button;
gint event_time;
g_return_if_fail (GLADE_IS_PLACEHOLDER (placeholder));
widget = glade_placeholder_get_parent (placeholder);
popup_menu = glade_popup_create_menu (widget, placeholder,
glade_widget_get_project (widget), TRUE);
if (event)
{
button = event->button;
event_time = event->time;
}
else
{
button = 0;
event_time = gtk_get_current_event_time ();
}
gtk_menu_popup (GTK_MENU (popup_menu), NULL, NULL,
NULL, NULL, button, event_time);
}
static gboolean
glade_gtk_grid_widget_exceeds_bounds (GtkGrid *grid, gint n_rows, gint n_cols)
{
GList *list, *children;
gboolean ret = FALSE;
children = gtk_container_get_children (GTK_CONTAINER (grid));
for (list = children; list && list->data; list = g_list_next (list))
{
GladeGridAttachments attach;
GtkWidget *widget = list->data;
if (GLADE_IS_PLACEHOLDER (widget)) continue;
glade_gtk_grid_get_child_attachments (GTK_WIDGET (grid), widget, &attach);
if (attach.left_attach + attach.width > n_cols ||
attach.top_attach + attach.height > n_rows)
{
ret = TRUE;
break;
}
}
g_list_free (children);
return ret;
}
static void
glade_gtk_grid_parse_finished (GladeProject *project, GObject *container)
{
GladeWidget *gwidget = glade_widget_get_from_gobject (container);
GladeGridAttachments attach;
GList *list, *children;
gint row = 0, column = 0, n_row = 0, n_column = 0;
children = gtk_container_get_children (GTK_CONTAINER (container));
for (list = children; list; list = list->next)
{
GtkWidget *widget = list->data;
if (GLADE_IS_PLACEHOLDER (widget)) continue;
glade_gtk_grid_get_child_attachments (GTK_WIDGET (container), widget, &attach);
n_row = attach.top_attach + attach.height;
n_column = attach.left_attach + attach.width;
if (row < n_row) row = n_row;
if (column < n_column) column = n_column;
}
if (column) glade_widget_property_set (gwidget, "n-columns", column);
if (row) glade_widget_property_set (gwidget, "n-rows", row);
g_list_free (children);
/* Refresh placeholders only once after the project is finished parsing */
glade_gtk_grid_refresh_placeholders (GTK_GRID (container), TRUE);
}
void
glade_gtk_header_bar_add_child (GladeWidgetAdaptor *adaptor,
GObject *parent,
GObject *child)
{
GladeWidget *gbox, *gchild;
gint size;
gchar *special_child_type;
gchild = glade_widget_get_from_gobject (child);
if (gchild)
glade_widget_set_pack_action_visible (gchild, "remove_slot", FALSE);
special_child_type = g_object_get_data (child, "special-child-type");
d(g_message ("Add %s %p (special: %s)",
GLADE_IS_PLACEHOLDER (child) ? "placeholder" : "child",
child, special_child_type));
if (special_child_type && !strcmp (special_child_type, "title"))
{
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (parent), GTK_WIDGET (child));
return;
}
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->add (adaptor, parent, child);
gbox = glade_widget_get_from_gobject (parent);
if (!glade_widget_superuser ())
{
glade_widget_property_get (gbox, "size", &size);
glade_widget_property_set (gbox, "size", size);
}
}
static gboolean
glade_gtk_table_widget_exceeds_bounds (GtkTable * table, gint n_rows,
gint n_cols)
{
GList *list, *children;
gboolean ret = FALSE;
children = gtk_container_get_children (GTK_CONTAINER (table));
for (list = children; list && list->data; list = list->next)
{
GtkTableChild child;
glade_gtk_table_get_child_attachments (GTK_WIDGET (table),
GTK_WIDGET (list->data), &child);
if (GLADE_IS_PLACEHOLDER (child.widget) == FALSE &&
(child.right_attach > n_cols || child.bottom_attach > n_rows))
{
ret = TRUE;
break;
}
}
g_list_free (children);
return ret;
}
static void
glade_gtk_table_build_occupation_maps(GtkTable *table, guint n_columns, guint n_rows,
gchar **child_map, gpointer **placeholder_map)
{
guint i, j;
GList *list, *children = gtk_container_get_children (GTK_CONTAINER (table));
*child_map = g_malloc0(n_columns * n_rows * sizeof(gchar)); /* gchar is smaller than gboolean */
*placeholder_map = g_malloc0(n_columns * n_rows * sizeof(gpointer));
for (list = children; list && list->data; list = list->next)
{
GtkTableChild child;
glade_gtk_table_get_child_attachments (GTK_WIDGET (table),
GTK_WIDGET (list->data), &child);
if (GLADE_IS_PLACEHOLDER(list->data))
{
/* assumption: placeholders are always attached to exactly 1 cell */
TABLE_OCCUPIED(*placeholder_map, n_columns, child.left_attach, child.top_attach) = list->data;
}
else
{
for (i = child.left_attach; i < child.right_attach && i < n_columns; i++)
{
for (j = child.top_attach; j < child.bottom_attach && j < n_rows; j++)
{
TABLE_OCCUPIED(*child_map, n_columns, i, j) = 1;
}
}
}
}
g_list_free (children);
}
void
glade_gtk_grid_replace_child (GladeWidgetAdaptor *adaptor,
GObject *container,
GObject *current,
GObject *new_widget)
{
g_return_if_fail (GTK_IS_GRID (container));
g_return_if_fail (GTK_IS_WIDGET (current));
g_return_if_fail (GTK_IS_WIDGET (new_widget));
/* Chain Up */
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->replace_child (adaptor,
container,
current,
new_widget);
/* If we are replacing a GladeWidget, we must refresh placeholders
* because the widget may have spanned multiple rows/columns, we must
* not do so in the case we are pasting multiple widgets into a grid,
* where destroying placeholders results in default packing properties
* (since the remaining placeholder templates no longer exist, only the
* first pasted widget would have proper packing properties).
*/
if (!GLADE_IS_PLACEHOLDER (new_widget))
glade_gtk_grid_refresh_placeholders (GTK_GRID (container), FALSE);
}
void
glade_gtk_window_add_child (GladeWidgetAdaptor * adaptor,
GObject * object, GObject * child)
{
GtkWidget *bin_child;
gchar *special_child_type;
special_child_type = g_object_get_data (child, "special-child-type");
if (special_child_type && !strcmp (special_child_type, "titlebar"))
{
gtk_window_set_titlebar (GTK_WINDOW (object), GTK_WIDGET (child));
}
else
{
/* Get a placeholder out of the way before adding the child */
bin_child = gtk_bin_get_child (GTK_BIN (object));
if (bin_child)
{
if (GLADE_IS_PLACEHOLDER (bin_child))
gtk_container_remove (GTK_CONTAINER (object), bin_child);
else
{
g_critical ("Cant add more than one widget to a GtkWindow");
return;
}
}
gtk_container_add (GTK_CONTAINER (object), GTK_WIDGET (child));
}
}
static void
glade_gtk_box_set_size (GObject * object, const GValue * value)
{
GtkBox *box;
GList *child, *children;
guint new_size, old_size, i;
box = GTK_BOX (object);
g_return_if_fail (GTK_IS_BOX (box));
if (glade_util_object_is_loading (object))
return;
children = gtk_container_get_children (GTK_CONTAINER (box));
children = g_list_remove (children, gtk_box_get_center_widget (GTK_BOX (box)));
old_size = g_list_length (children);
new_size = g_value_get_int (value);
if (old_size == new_size)
{
g_list_free (children);
return;
}
/* Ensure placeholders first...
*/
for (i = 0; i < new_size; i++)
{
if (g_list_length (children) < (i + 1))
{
GtkWidget *placeholder = glade_placeholder_new ();
gint blank = glade_gtk_box_get_first_blank (box);
gtk_container_add (GTK_CONTAINER (box), placeholder);
gtk_box_reorder_child (box, placeholder, blank);
}
}
/* The box has shrunk. Remove the widgets that are on those slots */
for (child = g_list_last (children);
child && old_size > new_size; child = g_list_previous (child))
{
GtkWidget *child_widget = child->data;
/* Refuse to remove any widgets that are either GladeWidget objects
* or internal to the hierarchic entity (may be a composite widget,
* not all internal widgets have GladeWidgets).
*/
if (glade_widget_get_from_gobject (child_widget) ||
GLADE_IS_PLACEHOLDER (child_widget) == FALSE)
continue;
gtk_container_remove (GTK_CONTAINER (box), child_widget);
old_size--;
}
g_list_free (children);
}
void
glade_gtk_container_replace_child (GladeWidgetAdaptor * adaptor,
GtkWidget * container,
GtkWidget * current, GtkWidget * new_widget)
{
GParamSpec **param_spec;
GladePropertyClass *pclass;
GValue *value;
guint nproperties;
guint i;
g_return_if_fail (gtk_widget_get_parent (current) == container);
param_spec = gtk_container_class_list_child_properties
(G_OBJECT_GET_CLASS (container), &nproperties);
value = g_malloc0 (sizeof (GValue) * nproperties);
for (i = 0; i < nproperties; i++)
{
g_value_init (&value[i], param_spec[i]->value_type);
gtk_container_child_get_property
(GTK_CONTAINER (container), current, param_spec[i]->name, &value[i]);
}
gtk_container_remove (GTK_CONTAINER (container), current);
gtk_container_add (GTK_CONTAINER (container), new_widget);
for (i = 0; i < nproperties; i++)
{
/* If the added widget is a placeholder then we
* want to keep all the "tranfer-on-paste" properties
* as default so that it looks fresh (transfer-on-paste
* properties dont effect the position/slot inside a
* contianer)
*/
if (GLADE_IS_PLACEHOLDER (new_widget))
{
pclass = glade_widget_adaptor_get_pack_property_class
(adaptor, param_spec[i]->name);
if (pclass && glade_property_class_transfer_on_paste (pclass))
continue;
}
gtk_container_child_set_property
(GTK_CONTAINER (container), new_widget, param_spec[i]->name,
&value[i]);
}
for (i = 0; i < nproperties; i++)
g_value_unset (&value[i]);
g_free (param_spec);
g_free (value);
}
static void
use_center_child_toggled (GtkWidget * widget,
GladeActionBarEditor * box_editor)
{
GladeActionBarEditorPrivate *priv = box_editor->priv;
GladeWidget *gwidget = glade_editable_loaded_widget (GLADE_EDITABLE (box_editor));
GladeWidget *gcenter = NULL;
GtkWidget *box;
GtkWidget *center;
GladeProperty *property;
gboolean use_center_child;
if (glade_editable_loading (GLADE_EDITABLE (box_editor)) || !gwidget)
return;
/* Get new desired property state */
use_center_child = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->use_center_child));
/* Get any existing center child */
box = (GtkWidget *)glade_widget_get_object (gwidget);
center = gtk_action_bar_get_center_widget (GTK_ACTION_BAR (box));
if (center && !GLADE_IS_PLACEHOLDER (center))
gcenter = glade_widget_get_from_gobject (center);
glade_editable_block (GLADE_EDITABLE (box_editor));
if (use_center_child)
glade_command_push_group (_("Setting %s to use a center child"),
glade_widget_get_name (gwidget));
else
glade_command_push_group (_("Setting %s to not use a center child"),
glade_widget_get_name (gwidget));
/* If a project widget exists when were disabling center child, it needs
* to be removed first as a part of the issuing GladeCommand group
*/
if (gcenter)
{
GList list;
list.prev = list.next = NULL;
list.data = gcenter;
glade_command_delete (&list);
}
property = glade_widget_get_property (gwidget, "use-center-child");
glade_command_set_property (property, use_center_child);
glade_command_pop_group ();
glade_editable_unblock (GLADE_EDITABLE (box_editor));
/* reload buttons and sensitivity and stuff... */
glade_editable_load (GLADE_EDITABLE (box_editor), gwidget);
}
static void
count_children (GtkWidget *widget, gpointer data)
{
ChildrenData *cdata = data;
if (widget == cdata->custom_title)
return;
if ((GLADE_IS_PLACEHOLDER (widget) && cdata->include_placeholders) ||
glade_widget_get_from_gobject (widget) != NULL)
cdata->count++;
}
void
glade_gtk_header_bar_replace_child (GladeWidgetAdaptor * adaptor,
GObject * container,
GObject * current,
GObject * new_widget)
{
GladeWidget *gbox;
gchar *special_child_type;
gint size;
special_child_type =
g_object_get_data (G_OBJECT (current), "special-child-type");
d(g_message ("Replace %s %p (special: %s) with %s %p",
GLADE_IS_PLACEHOLDER (current) ? "placeholder" : "child",
current, special_child_type,
GLADE_IS_PLACEHOLDER (new_widget) ? "placeholder" : "child",
new_widget));
if (special_child_type && !strcmp (special_child_type, "title"))
{
g_object_set_data (G_OBJECT (new_widget), "special-child-type", "title");
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (container), GTK_WIDGET (new_widget));
return;
}
else
g_object_set_data (G_OBJECT (new_widget), "special-child-type", NULL);
GWA_GET_CLASS
(GTK_TYPE_CONTAINER)->replace_child (adaptor, container, current, new_widget);
gbox = glade_widget_get_from_gobject (container);
if (!glade_widget_superuser ())
{
glade_widget_property_get (gbox, "size", &size);
glade_widget_property_set (gbox, "size", size);
}
}
void
glade_gtk_header_bar_set_use_custom_title (GObject *object,
gboolean use_custom_title)
{
GladeWidget *gwidget = glade_widget_get_from_gobject (object);
GtkWidget *child;
if (use_custom_title)
{
child = gtk_header_bar_get_custom_title (GTK_HEADER_BAR (object));
if (!child)
{
child = glade_placeholder_new ();
g_object_set_data (G_OBJECT (child), "special-child-type", "title");
}
}
else
child = NULL;
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (object), child);
if (GLADE_IS_PLACEHOLDER (child))
{
GList *list, *l;
list = glade_placeholder_packing_actions (GLADE_PLACEHOLDER (child));
for (l = list; l; l = l->next)
{
GladeWidgetAction *gwa = l->data;
if (!strcmp (glade_widget_action_get_class (gwa)->id, "remove_slot"))
glade_widget_action_set_visible (gwa, FALSE);
}
}
if (use_custom_title)
{
glade_widget_property_set_sensitive (gwidget, "title", FALSE, TITLE_DISABLED_MESSAGE);
glade_widget_property_set_sensitive (gwidget, "subtitle", FALSE, TITLE_DISABLED_MESSAGE);
glade_widget_property_set_sensitive (gwidget, "has-subtitle", FALSE, TITLE_DISABLED_MESSAGE);
}
else
{
glade_widget_property_set_sensitive (gwidget, "title", TRUE, NULL);
glade_widget_property_set_sensitive (gwidget, "subtitle", TRUE, NULL);
glade_widget_property_set_sensitive (gwidget, "has-subtitle", TRUE, NULL);
}
}
void
glade_gtk_button_set_property (GladeWidgetAdaptor * adaptor,
GObject * object,
const gchar * id, const GValue * value)
{
GladeWidget *widget = glade_widget_get_from_gobject (object);
GladeProperty *property = glade_widget_get_property (widget, id);
if (strcmp (id, "custom-child") == 0)
{
GtkWidget *child = gtk_bin_get_child (GTK_BIN (object));
gboolean custom_child = g_value_get_boolean (value);
/* Avoid removing a child if we already have a custom child */
if (custom_child && (child && glade_widget_get_from_gobject (child)))
return;
if (custom_child)
{
if (child)
gtk_container_remove (GTK_CONTAINER (object), child);
gtk_container_add (GTK_CONTAINER (object), glade_placeholder_new ());
}
else if (child && GLADE_IS_PLACEHOLDER (child))
gtk_container_remove (GTK_CONTAINER (object), child);
}
else if (strcmp (id, "stock") == 0)
{
gboolean use_stock = FALSE;
glade_widget_property_get (widget, "use-stock", &use_stock);
if (use_stock)
gtk_button_set_label (GTK_BUTTON (object), g_value_get_string (value));
}
else if (strcmp (id, "use-stock") == 0)
{
/* I guess its my bug in GTK+, we need to resync the appearance property
* on GtkButton when the GtkButton:use-stock property changes.
*/
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->set_property (adaptor, object,
id, value);
glade_gtk_sync_use_appearance (widget);
}
else if (GPC_VERSION_CHECK (glade_property_get_class (property), gtk_major_version, gtk_minor_version + 1))
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->set_property (adaptor, object, id, value);
}
void
glade_gtk_container_add_child (GladeWidgetAdaptor * adaptor,
GtkWidget * container, GtkWidget * child)
{
GtkWidget *container_child = NULL;
if (GTK_IS_BIN (container))
container_child = gtk_bin_get_child (GTK_BIN (container));
/* Get a placeholder out of the way before adding the child if its a GtkBin
*/
if (GTK_IS_BIN (container) && container_child != NULL &&
GLADE_IS_PLACEHOLDER (container_child))
gtk_container_remove (GTK_CONTAINER (container), container_child);
gtk_container_add (GTK_CONTAINER (container), child);
}
void
glade_gtk_overlay_add_child (GladeWidgetAdaptor *adaptor,
GObject *object,
GObject *child)
{
gchar *special_type = g_object_get_data (child, "special-child-type");
GtkWidget *bin_child;
if ((special_type && !strcmp (special_type, "overlay")) ||
((bin_child = gtk_bin_get_child (GTK_BIN (object))) &&
!GLADE_IS_PLACEHOLDER (bin_child)))
{
g_object_set_data (child, "special-child-type", "overlay");
gtk_overlay_add_overlay (GTK_OVERLAY (object), GTK_WIDGET (child));
}
else
/* Chain Up */
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->add (adaptor, object, child);
}
static void
glade_gtk_grid_refresh_placeholders (GtkGrid *grid,
gboolean load_finished)
{
GladeWidget *widget;
GladeProject *project;
GtkContainer *container;
GList *list, *children;
guint n_columns, n_rows;
gint i, j;
widget = glade_widget_get_from_gobject (grid);
project = glade_widget_get_project (widget);
/* Wait for project to finish loading */
if ((project && glade_project_is_loading (project)) && !load_finished)
return;
glade_widget_property_get (widget, "n-columns", &n_columns);
glade_widget_property_get (widget, "n-rows", &n_rows);
container = GTK_CONTAINER (grid);
children = gtk_container_get_children (container);
for (list = children; list && list->data; list = list->next)
{
GtkWidget *child = list->data;
if (GLADE_IS_PLACEHOLDER (child))
gtk_container_remove (container, child);
}
g_list_free (children);
children = gtk_container_get_children (container);
for (i = 0; i < n_columns; i++)
for (j = 0; j < n_rows; j++)
if (glade_gtk_grid_has_child (grid, children, i, j) == FALSE)
gtk_grid_attach (grid, glade_placeholder_new (), i, j, 1, 1);
if (gtk_widget_get_realized (GTK_WIDGET (grid)))
gtk_container_check_resize (container);
g_list_free (children);
}
void
glade_gtk_sheet_replace_child(
GladeWidgetAdaptor *adaptor,
GObject *object,
GObject *old_obj,
GObject *new_obj)
{
gint col;
GtkSheet *sheet;
GtkSheetColumn *oldcol, *newcol;
#ifdef GTK_SHEET_DEBUG
g_debug("glade_gtk_sheet_replace_child: called %p -> %p", old_obj, new_obj);
#endif
g_return_if_fail (GTK_IS_SHEET (object));
g_return_if_fail (GTK_IS_WIDGET (old_obj));
if (GLADE_IS_PLACEHOLDER (new_obj))
{
glade_gtk_sheet_remove_child (adaptor, object, old_obj);
return;
}
g_return_if_fail (GTK_IS_WIDGET (new_obj));
sheet = GTK_SHEET(object);
oldcol = GTK_SHEET_COLUMN(old_obj);
newcol = GTK_SHEET_COLUMN(new_obj);
for (col=0; col<=sheet->maxcol; col++)
{
if (oldcol == sheet->column[col])
{
g_object_unref(sheet->column[col]);
sheet->column[col] = newcol;
return;
}
}
g_warning("glade_gtk_sheet_replace_child: couldn't replace child %p by %p", old_obj, new_obj);
}
void
glade_gtk_table_replace_child (GladeWidgetAdaptor * adaptor,
GtkWidget * container,
GtkWidget * current, GtkWidget * new_widget)
{
/* Chain Up */
GWA_GET_CLASS
(GTK_TYPE_CONTAINER)->replace_child (adaptor,
G_OBJECT (container),
G_OBJECT (current),
G_OBJECT (new_widget));
/* If we are replacing a GladeWidget, we must refresh placeholders
* because the widget may have spanned multiple rows/columns, we must
* not do so in the case we are pasting multiple widgets into a table,
* where destroying placeholders results in default packing properties
* (since the remaining placeholder templates no longer exist, only the
* first pasted widget would have proper packing properties).
*/
if (!GLADE_IS_PLACEHOLDER (new_widget))
glade_gtk_table_refresh_placeholders (GTK_TABLE (container));
}
void
glade_gtk_header_bar_remove_child (GladeWidgetAdaptor * adaptor,
GObject * object,
GObject * child)
{
GladeWidget *gbox;
gint size;
gchar *special_child_type;
special_child_type = g_object_get_data (child, "special-child-type");
d(g_message ("Remove %s %p (special: %s)",
GLADE_IS_PLACEHOLDER (child) ? "placeholder" : "child",
child, special_child_type));
if (special_child_type && !strcmp (special_child_type, "title"))
{
GtkWidget *replacement = glade_placeholder_new ();
g_object_set_data (G_OBJECT (replacement), "special-child-type", "title");
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (object), replacement);
return;
}
gtk_container_remove (GTK_CONTAINER (object), GTK_WIDGET (child));
/* Synchronize number of placeholders, this should trigger the set_property method with the
* correct value (not the arbitrary number of children currently in the headerbar)
*/
gbox = glade_widget_get_from_gobject (object);
if (!glade_widget_superuser ())
{
glade_widget_property_get (gbox, "size", &size);
glade_widget_property_set (gbox, "size", size);
}
}
void
glade_gtk_box_add_child (GladeWidgetAdaptor * adaptor,
GObject * object, GObject * child)
{
GladeWidget *gbox, *gchild;
gint num_children;
gchar *special_child_type;
g_return_if_fail (GTK_IS_BOX (object));
g_return_if_fail (GTK_IS_WIDGET (child));
gbox = glade_widget_get_from_gobject (object);
special_child_type = g_object_get_data (child, "special-child-type");
if (special_child_type && !strcmp (special_child_type, "center"))
{
gtk_box_set_center_widget (GTK_BOX (object), GTK_WIDGET (child));
return;
}
/*
Try to remove the last placeholder if any, this way GtkBox`s size
will not be changed.
*/
if (glade_widget_superuser () == FALSE && !GLADE_IS_PLACEHOLDER (child))
{
GList *l, *children;
GtkBox *box = GTK_BOX (object);
children = gtk_container_get_children (GTK_CONTAINER (box));
for (l = g_list_last (children); l; l = g_list_previous (l))
{
GtkWidget *child_widget = l->data;
if (GLADE_IS_PLACEHOLDER (child_widget))
{
gtk_container_remove (GTK_CONTAINER (box), child_widget);
break;
}
}
g_list_free (children);
}
gtk_container_add (GTK_CONTAINER (object), GTK_WIDGET (child));
num_children = glade_gtk_box_get_num_children (object);
glade_widget_property_set (gbox, "size", num_children);
gchild = glade_widget_get_from_gobject (child);
/* The "Remove Slot" operation only makes sence on placeholders,
* otherwise its a "Delete" operation on the child widget.
*/
if (gchild)
glade_widget_set_pack_action_visible (gchild, "remove_slot", FALSE);
fix_response_id_on_child (gbox, child, TRUE);
if (glade_widget_superuser ())
return;
/* Packing props arent around when parenting during a glade_widget_dup() */
if (gchild && glade_widget_get_packing_properties (gchild))
glade_widget_pack_property_set (gchild, "position", num_children - 1);
}
static void
use_csd_toggled (GtkWidget *widget,
GladeWindowEditor *window_editor)
{
GladeWindowEditorPrivate *priv = window_editor->priv;
GladeWidget *gwidget = glade_editable_loaded_widget (GLADE_EDITABLE (window_editor));
GladeWidget *gtitlebar = NULL;
GtkWidget *window;
GtkWidget *titlebar;
GladeProperty *property;
gboolean use_csd;
if (glade_editable_loading (GLADE_EDITABLE (window_editor)) || !gwidget)
return;
/* Get new desired property state */
use_csd = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->use_csd_check));
/* Get any existing titlebar widget */
window = (GtkWidget *)glade_widget_get_object (gwidget);
titlebar = gtk_window_get_titlebar (GTK_WINDOW (window));
if (titlebar && !GLADE_IS_PLACEHOLDER (titlebar))
gtitlebar = glade_widget_get_from_gobject (titlebar);
glade_editable_block (GLADE_EDITABLE (window_editor));
if (use_csd)
glade_command_push_group (_("Setting %s to use a custom titlebar"),
glade_widget_get_name (gwidget));
else
glade_command_push_group (_("Setting %s to use a system provided titlebar"),
glade_widget_get_name (gwidget));
/* If a project widget exists when were disabling CSD, it needs
* to be removed first as a part of the issuing GladeCommand group
*/
if (gtitlebar)
{
GList list;
list.prev = list.next = NULL;
list.data = gtitlebar;
glade_command_delete (&list);
}
property = glade_widget_get_property (gwidget, "use-csd");
glade_command_set_property (property, use_csd);
if (use_csd)
{
property = glade_widget_get_property (gwidget, "title");
glade_command_set_property (property, NULL);
property = glade_widget_get_property (gwidget, "decorated");
glade_command_set_property (property, TRUE);
property = glade_widget_get_property (gwidget, "hide-titlebar-when-maximized");
glade_command_set_property (property, FALSE);
}
glade_command_pop_group ();
glade_editable_unblock (GLADE_EDITABLE (window_editor));
/* reload buttons and sensitivity and stuff... */
glade_editable_load (GLADE_EDITABLE (window_editor), gwidget);
}
