static void
glade_window_editor_load (GladeEditable *editable,
GladeWidget *gwidget)
{
GladeWindowEditor *window_editor = GLADE_WINDOW_EDITOR (editable);
GladeWindowEditorPrivate *priv = window_editor->priv;
/* Chain up to default implementation */
parent_editable_iface->load (editable, gwidget);
if (gwidget)
{
gboolean icon_name;
gboolean use_csd;
glade_widget_property_get (gwidget, "glade-window-icon-name", &icon_name);
glade_widget_property_get (gwidget, "use-csd", &use_csd);
if (icon_name)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->icon_name_radio), TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->icon_file_radio), TRUE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->use_csd_check), use_csd);
}
}
static void
glade_gtk_fixed_layout_sync_size_requests (GtkWidget *widget)
{
GList *children, *l;
if ((children = gtk_container_get_children (GTK_CONTAINER (widget))) != NULL)
{
for (l = children; l; l = l->next)
{
GtkWidget *child = l->data;
GladeWidget *gchild = glade_widget_get_from_gobject (child);
gint width = -1, height = -1;
if (!gchild)
continue;
glade_widget_property_get (gchild, "width-request", &width);
glade_widget_property_get (gchild, "height-request", &height);
gtk_widget_set_size_request (child, width, height);
}
g_list_free (children);
}
}
static void
glade_gtk_grid_set_n_common (GObject *object,
const GValue *value,
gboolean for_rows)
{
GladeWidget *widget;
GtkGrid *grid;
guint new_size, n_columns, n_rows;
grid = GTK_GRID (object);
widget = glade_widget_get_from_gobject (GTK_WIDGET (grid));
glade_widget_property_get (widget, "n-columns", &n_columns);
glade_widget_property_get (widget, "n-rows", &n_rows);
new_size = g_value_get_uint (value);
if (new_size < 1)
return;
if (glade_gtk_grid_widget_exceeds_bounds
(grid, for_rows ? new_size : n_rows, for_rows ? n_columns : new_size))
/* Refuse to shrink if it means orphaning widgets */
return;
/* Fill grid with placeholders */
glade_gtk_grid_refresh_placeholders (grid, FALSE);
}
static void
glade_gtk_button_update_stock (GladeWidget *widget)
{
gboolean use_stock;
gchar *label = NULL;
/* Update the stock property */
glade_widget_property_get (widget, "use-stock", &use_stock);
if (use_stock)
{
glade_widget_property_get (widget, "label", &label);
glade_widget_property_set (widget, "stock", label);
}
}
static void
glade_gtk_icon_factory_write_sources (GladeWidget *widget,
GladeXmlContext *context,
GladeXmlNode *node)
{
GladeXmlNode *sources_node;
GladeIconSources *sources = NULL;
SourceWriteTab tab;
glade_widget_property_get (widget, "sources", &sources);
if (!sources)
return;
sources_node = glade_xml_node_new (context, GLADE_TAG_SOURCES);
tab.context = context;
tab.node = sources_node;
g_hash_table_foreach (sources->sources, (GHFunc) write_icon_sources, &tab);
if (!glade_xml_node_get_children (sources_node))
glade_xml_node_delete (sources_node);
else
glade_xml_node_append_child (node, sources_node);
}
void
glade_gtk_box_remove_child (GladeWidgetAdaptor * adaptor,
GObject * object, GObject * child)
{
GladeWidget *gbox;
gint size;
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"))
{
GtkWidget *w;
w = glade_placeholder_new ();
g_object_set_data (G_OBJECT (w), "special-child-type", "center");
gtk_box_set_center_widget (GTK_BOX (object), w);
return;
}
gtk_container_remove (GTK_CONTAINER (object), GTK_WIDGET (child));
if (glade_widget_superuser () == FALSE)
{
glade_widget_property_get (gbox, "size", &size);
glade_widget_property_set (gbox, "size", size);
}
fix_response_id_on_child (gbox, child, FALSE);
}
void
glade_gtk_button_read_widget (GladeWidgetAdaptor * adaptor,
GladeWidget * widget, GladeXmlNode * node)
{
GObject *object;
if (!(glade_xml_node_verify_silent (node, GLADE_XML_TAG_WIDGET) ||
glade_xml_node_verify_silent (node, GLADE_XML_TAG_TEMPLATE)))
return;
/* First chain up and read in all the normal properties.. */
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->read_widget (adaptor, widget, node);
glade_gtk_button_update_stock (widget);
/* Fold "font-name" property into the "font" propery */
object = glade_widget_get_object (widget);
if (GTK_IS_FONT_BUTTON (object))
{
gchar *font_prop_value = NULL;
glade_widget_property_get (widget, "font-name", &font_prop_value);
if (font_prop_value != NULL)
{
glade_widget_property_set (widget, "font", font_prop_value);
glade_widget_property_set (widget, "font-name", NULL);
}
}
}
void
glade_gtk_action_bar_remove_child (GladeWidgetAdaptor * adaptor,
GObject * object,
GObject * child)
{
GladeWidget *gbox;
gint size;
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"))
{
GtkWidget *w;
w = glade_placeholder_new ();
g_object_set_data (G_OBJECT (w), "special-child-type", "center");
gtk_action_bar_set_center_widget (GTK_ACTION_BAR (object), w);
return;
}
gtk_container_remove (GTK_CONTAINER (object), GTK_WIDGET (child));
if (!glade_widget_superuser ())
{
glade_widget_property_get (gbox, "size", &size);
glade_widget_property_set (gbox, "size", size);
}
}
void
glade_gtk_widget_read_widget (GladeWidgetAdaptor * adaptor,
GladeWidget * widget, GladeXmlNode * node)
{
const gchar *tooltip_markup = NULL;
if (!(glade_xml_node_verify_silent (node, GLADE_XML_TAG_WIDGET) ||
glade_xml_node_verify_silent (node, GLADE_XML_TAG_TEMPLATE)))
return;
/* First chain up and read in all the normal properties.. */
GWA_GET_CLASS (G_TYPE_OBJECT)->read_widget (adaptor, widget, node);
/* Read in accelerators */
glade_gtk_read_accels (widget, node, TRUE);
/* Read in atk props */
glade_gtk_widget_read_atk_props (widget, node);
/* Read in the style classes */
glade_gtk_widget_read_style_classes (widget, node);
/* Resolve the virtual tooltip use markup property */
glade_widget_property_get (widget, "tooltip-markup", &tooltip_markup);
if (tooltip_markup != NULL)
glade_widget_property_set (widget, "glade-tooltip-markup", TRUE);
}
static void
glade_tool_item_group_editor_load (GladeEditable *editable, GladeWidget *widget)
{
GladeToolItemGroupEditor *group_editor = GLADE_TOOL_ITEM_GROUP_EDITOR (editable);
gboolean custom_label = FALSE;
GList *l;
/* Chain up to default implementation */
parent_editable_iface->load (editable, widget);
/* load the embedded editable... */
if (group_editor->embed)
glade_editable_load (GLADE_EDITABLE (group_editor->embed), widget);
for (l = group_editor->properties; l; l = l->next)
glade_editor_property_load_by_widget (GLADE_EDITOR_PROPERTY (l->data),
widget);
if (widget)
{
glade_widget_property_get (widget, "custom-label", &custom_label);
if (custom_label)
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (group_editor->label_widget_radio), TRUE);
else
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (group_editor->label_radio), TRUE);
}
}
static void
glade_eprop_model_data_add_row (GladeEditorProperty * eprop)
{
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GValue value = { 0, };
GNode *node = NULL;
GList *columns = NULL;
GladeProperty *property = glade_editor_property_get_property (eprop);
glade_property_get (property, &node);
glade_widget_property_get (glade_property_get_widget (property), "columns", &columns);
if (!columns)
return;
clear_view (eprop);
if (!node)
node = g_node_new (NULL);
else
node = glade_model_data_tree_copy (node);
append_row (node, columns);
eprop_data->adding_row = TRUE;
g_value_init (&value, GLADE_TYPE_MODEL_DATA_TREE);
g_value_take_boxed (&value, node);
glade_editor_property_commit (eprop, &value);
g_value_unset (&value);
eprop_data->adding_row = FALSE;
}
static void
glade_gtk_widget_write_style_classes (GladeWidget * widget,
GladeXmlContext * context,
GladeXmlNode * node)
{
GladeXmlNode *class_node, *style_node;
GList *string_list = NULL, *l;
GladeString *string;
if (!glade_widget_property_get (widget, "glade-style-classes", &string_list) || !string_list)
return;
style_node = glade_xml_node_new (context, GLADE_TAG_STYLE);
for (l = string_list; l; l = l->next)
{
string = l->data;
class_node = glade_xml_node_new (context, GLADE_TAG_CLASS);
glade_xml_node_append_child (style_node, class_node);
glade_xml_node_set_property_string (class_node,
GLADE_TAG_NAME,
string->string);
}
if (!glade_xml_node_get_children (style_node))
glade_xml_node_delete (style_node);
else
glade_xml_node_append_child (node, style_node);
}
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 void
glade_gtk_filter_write_strings (GladeWidget *widget,
GladeXmlContext *context,
GladeXmlNode *node,
FilterType type,
const gchar *property_name)
{
GladeXmlNode *item_node;
GList *string_list = NULL, *l;
GladeString *string;
const gchar *string_tag;
switch (type)
{
case FILTER_PATTERN: string_tag = GLADE_TAG_PATTERN; break;
case FILTER_MIME: string_tag = GLADE_TAG_MIME_TYPE; break;
case FILTER_APPLICATION: string_tag = GLADE_TAG_APPLICATION; break;
default:
g_assert_not_reached ();
break;
}
if (!glade_widget_property_get (widget, property_name, &string_list) || !string_list)
return;
for (l = string_list; l; l = l->next)
{
string = l->data;
item_node = glade_xml_node_new (context, string_tag);
glade_xml_node_append_child (node, item_node);
glade_xml_set_content (item_node, string->string);
}
}
static void
glade_gtk_size_group_write_widgets (GladeWidget * widget,
GladeXmlContext * context,
GladeXmlNode * node)
{
GladeXmlNode *widgets_node, *widget_node;
GList *widgets = NULL, *list;
GladeWidget *awidget;
widgets_node = glade_xml_node_new (context, GLADE_TAG_SIZEGROUP_WIDGETS);
if (glade_widget_property_get (widget, "widgets", &widgets))
{
for (list = widgets; list; list = list->next)
{
awidget = glade_widget_get_from_gobject (list->data);
widget_node =
glade_xml_node_new (context, GLADE_TAG_SIZEGROUP_WIDGET);
glade_xml_node_append_child (widgets_node, widget_node);
glade_xml_node_set_property_string (widget_node, GLADE_TAG_NAME,
glade_widget_get_name (awidget));
}
}
if (!glade_xml_node_get_children (widgets_node))
glade_xml_node_delete (widgets_node);
else
glade_xml_node_append_child (node, widgets_node);
}
static void
glade_gtk_window_write_accel_groups (GladeWidget * widget,
GladeXmlContext * context,
GladeXmlNode * node)
{
GladeXmlNode *groups_node, *group_node;
GList *groups = NULL, *list;
GladeWidget *agroup;
groups_node = glade_xml_node_new (context, GLADE_TAG_ACCEL_GROUPS);
if (glade_widget_property_get (widget, "accel-groups", &groups))
{
for (list = groups; list; list = list->next)
{
agroup = glade_widget_get_from_gobject (list->data);
group_node = glade_xml_node_new (context, GLADE_TAG_ACCEL_GROUP);
glade_xml_node_append_child (groups_node, group_node);
glade_xml_node_set_property_string (group_node, GLADE_TAG_NAME,
glade_widget_get_name (agroup));
}
}
if (!glade_xml_node_get_children (groups_node))
glade_xml_node_delete (groups_node);
else
glade_xml_node_append_child (node, groups_node);
}
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);
}
static gboolean
glade_gtk_grid_verify_n_common (GObject *object,
const GValue *value,
gboolean for_rows)
{
GtkGrid *grid = GTK_GRID (object);
GladeWidget *widget;
guint n_columns, n_rows, new_size = g_value_get_uint (value);
widget = glade_widget_get_from_gobject (GTK_WIDGET (grid));
glade_widget_property_get (widget, "n-columns", &n_columns);
glade_widget_property_get (widget, "n-rows", &n_rows);
if (glade_gtk_grid_widget_exceeds_bounds
(grid, for_rows ? new_size : n_rows, for_rows ? n_columns : new_size))
/* Refuse to shrink if it means orphaning widgets */
return FALSE;
return TRUE;
}
static void
glade_gtk_entry_changed (GtkEditable * editable, GladeWidget * gentry)
{
const gchar *text, *text_prop;
GladeProperty *prop;
gboolean use_buffer;
if (glade_widget_superuser ())
return;
text = gtk_entry_get_text (GTK_ENTRY (editable));
glade_widget_property_get (gentry, "text", &text_prop);
glade_widget_property_get (gentry, "use-entry-buffer", &use_buffer);
if (use_buffer == FALSE && g_strcmp0 (text, text_prop))
{
if ((prop = glade_widget_get_property (gentry, "text")))
glade_command_set_property (prop, text);
}
}
static gboolean
glade_gtk_table_verify_attach_common (GObject * object,
GValue * value,
guint * val,
const gchar * prop,
guint * prop_val,
const gchar * parent_prop,
guint * parent_val)
{
GladeWidget *widget, *parent;
widget = glade_widget_get_from_gobject (object);
g_return_val_if_fail (GLADE_IS_WIDGET (widget), TRUE);
parent = glade_widget_get_parent (widget);
g_return_val_if_fail (GLADE_IS_WIDGET (parent), TRUE);
*val = g_value_get_uint (value);
glade_widget_property_get (widget, prop, prop_val);
glade_widget_property_get (parent, parent_prop, parent_val);
return FALSE;
}
void
glade_gtk_button_write_widget (GladeWidgetAdaptor * adaptor,
GladeWidget * widget,
GladeXmlContext * context, GladeXmlNode * node)
{
GladeProperty *prop;
gboolean use_stock;
gchar *stock = NULL;
if (!(glade_xml_node_verify_silent (node, GLADE_XML_TAG_WIDGET) ||
glade_xml_node_verify_silent (node, GLADE_XML_TAG_TEMPLATE)))
return;
/* Do not save GtkColorButton GtkFontButton and GtkScaleButton label property */
if (!(GTK_IS_COLOR_BUTTON (glade_widget_get_object (widget)) ||
GTK_IS_FONT_BUTTON (glade_widget_get_object (widget)) ||
GTK_IS_SCALE_BUTTON (glade_widget_get_object (widget))))
{
/* Make a copy of the GladeProperty,
* override its value and ensure non-translatable if use-stock is TRUE
*/
prop = glade_widget_get_property (widget, "label");
prop = glade_property_dup (prop, widget);
glade_widget_property_get (widget, "use-stock", &use_stock);
if (use_stock)
{
glade_widget_property_get (widget, "stock", &stock);
glade_property_i18n_set_translatable (prop, FALSE);
glade_property_set (prop, stock);
}
glade_property_write (prop, context, node);
g_object_unref (G_OBJECT (prop));
}
/* Write out other normal properties and any other class derived custom properties after ... */
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->write_widget (adaptor, widget, context,
node);
}
static void
glade_gtk_tool_button_parse_finished (GladeProject * project,
GladeWidget * widget)
{
gchar *stock_str = NULL, *icon_name = NULL;
gint stock_id = 0;
GtkWidget *label_widget = NULL, *image_widget = NULL;
glade_widget_property_get (widget, "stock-id", &stock_str);
glade_widget_property_get (widget, "icon-name", &icon_name);
glade_widget_property_get (widget, "icon-widget", &image_widget);
glade_widget_property_get (widget, "label-widget", &label_widget);
if (label_widget)
glade_widget_property_set (widget, "custom-label", TRUE);
else
glade_widget_property_set (widget, "custom-label", FALSE);
if (image_widget)
glade_widget_property_set (widget, "image-mode", GLADE_TB_MODE_CUSTOM);
else if (icon_name)
glade_widget_property_set (widget, "image-mode", GLADE_TB_MODE_ICON);
else if (stock_str)
{
/* Update the stock property */
stock_id =
glade_utils_enum_value_from_string (GLADE_TYPE_STOCK_IMAGE,
stock_str);
if (stock_id < 0)
stock_id = 0;
glade_widget_property_set (widget, "glade-stock", stock_id);
glade_widget_property_set (widget, "image-mode", GLADE_TB_MODE_STOCK);
}
else
glade_widget_property_set (widget, "image-mode", GLADE_TB_MODE_STOCK);
}
static void
glade_widget_editor_load (GladeEditable * editable, GladeWidget * gwidget)
{
GladeWidgetEditor *widget_editor = GLADE_WIDGET_EDITOR (editable);
GladeWidgetEditorPrivate *priv = widget_editor->priv;
/* Chain up to default implementation */
parent_editable_iface->load (editable, gwidget);
if (gwidget)
{
GtkWidget *widget = (GtkWidget *)glade_widget_get_object (gwidget);
gboolean is_container = GTK_IS_CONTAINER (widget);
gboolean tooltip_markup = FALSE;
gboolean custom_tooltip = FALSE;
glade_widget_property_get (gwidget, "glade-tooltip-markup", &tooltip_markup);
glade_widget_property_get (gwidget, "has-tooltip", &custom_tooltip);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->tooltip_markup_check), tooltip_markup);
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->tooltip_label_notebook),
tooltip_markup ? TOOLTIP_MARKUP_PAGE : TOOLTIP_TEXT_PAGE);
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->tooltip_editor_notebook),
tooltip_markup ? TOOLTIP_MARKUP_PAGE : TOOLTIP_TEXT_PAGE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->custom_tooltip_check), custom_tooltip);
gtk_widget_set_sensitive (priv->tooltip_markup_check, !custom_tooltip);
gtk_widget_set_sensitive (priv->tooltip_label_notebook, !custom_tooltip);
gtk_widget_set_sensitive (priv->tooltip_editor_notebook, !custom_tooltip);
/* Set visibility of GtkContainer only properties */
gtk_widget_set_visible (priv->resize_mode_label, is_container);
gtk_widget_set_visible (priv->resize_mode_editor, is_container);
gtk_widget_set_visible (priv->border_width_label, is_container);
gtk_widget_set_visible (priv->border_width_editor, is_container);
}
}
void
glade_gtk_image_set_property (GladeWidgetAdaptor *adaptor,
GObject *object,
const gchar *id,
const GValue *value)
{
if (!strcmp (id, "image-mode"))
glade_gtk_image_set_image_mode (object, value);
else if (!strcmp (id, "icon-size"))
{
/* Make the enum an int... */
GValue int_value = { 0, };
g_value_init (&int_value, G_TYPE_INT);
g_value_set_int (&int_value, g_value_get_enum (value));
GWA_GET_CLASS (GTK_TYPE_WIDGET)->set_property (adaptor, object, id,
&int_value);
g_value_unset (&int_value);
}
else
{
GladeWidget *widget = glade_widget_get_from_gobject (object);
GladeImageEditMode mode = 0;
glade_widget_property_get (widget, "image-mode", &mode);
/* avoid setting properties in the wrong mode... */
switch (mode)
{
case GLADE_IMAGE_MODE_STOCK:
if (!strcmp (id, "icon-name") || !strcmp (id, "pixbuf"))
return;
break;
case GLADE_IMAGE_MODE_ICON:
if (!strcmp (id, "stock") || !strcmp (id, "pixbuf"))
return;
break;
case GLADE_IMAGE_MODE_FILENAME:
if (!strcmp (id, "stock") || !strcmp (id, "icon-name"))
return;
case GLADE_IMAGE_MODE_RESOURCE:
/* Screw the resource mode here, we can't apply them at Glade's runtime anyway */
default:
break;
}
GWA_GET_CLASS (GTK_TYPE_WIDGET)->set_property (adaptor, object,
id, value);
}
}
static gboolean
glade_gtk_grid_verify_attach_common (GObject *object,
GValue *value,
const gchar *prop,
const gchar *parent_prop)
{
GladeWidget *widget, *parent;
guint parent_val;
gint val, prop_val;
widget = glade_widget_get_from_gobject (object);
g_return_val_if_fail (GLADE_IS_WIDGET (widget), TRUE);
parent = glade_widget_get_parent (widget);
g_return_val_if_fail (GLADE_IS_WIDGET (parent), TRUE);
val = g_value_get_int (value);
glade_widget_property_get (widget, prop, &prop_val);
glade_widget_property_get (parent, parent_prop, &parent_val);
if (val < 0 || (val+prop_val) > parent_val)
return FALSE;
return TRUE;
}
static void
glade_gtk_menu_item_set_label (GObject * object, const GValue * value)
{
GladeWidget *gitem;
GtkWidget *label;
gboolean use_underline;
gitem = glade_widget_get_from_gobject (object);
label = gtk_bin_get_child (GTK_BIN (object));
gtk_label_set_text (GTK_LABEL (label), g_value_get_string (value));
/* Update underline incase... */
glade_widget_property_get (gitem, "use-underline", &use_underline);
gtk_label_set_use_underline (GTK_LABEL (label), use_underline);
}
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);
}
static void
glade_notebook_editor_load (GladeEditable * editable, GladeWidget * widget)
{
GladeNotebookEditor *notebook_editor = GLADE_NOTEBOOK_EDITOR (editable);
GladeNotebookEditorPrivate *priv = notebook_editor->priv;
gboolean show_tabs = FALSE;
/* Chain up to default implementation */
parent_editable_iface->load (editable, widget);
if (widget)
{
glade_widget_property_get (widget, "show-tabs", &show_tabs);
gtk_widget_set_visible (priv->tabs_grid, show_tabs);
}
}
static void
glade_action_bar_editor_load (GladeEditable *editable,
GladeWidget *gwidget)
{
GladeActionBarEditor *box_editor = GLADE_ACTION_BAR_EDITOR (editable);
GladeActionBarEditorPrivate *priv = box_editor->priv;
/* Chain up to default implementation */
parent_editable_iface->load (editable, gwidget);
if (gwidget)
{
gboolean use_center_child;
glade_widget_property_get (gwidget, "use-center-child", &use_center_child);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->use_center_child), use_center_child);
}
}
static gchar *
glade_gtk_sheet_layout_get_display_name (GladeBaseEditor *editor,
GladeWidget *gchild,
gpointer user_data)
{
GObject *child = glade_widget_get_object (gchild);
gchar *name;
if (GTK_IS_TREE_VIEW_COLUMN (child))
glade_widget_property_get (gchild, "title", &name);
else
name = gchild->name;
#ifdef GTK_SHEET_DEBUG
g_debug("glade_gtk_sheet_layout_get_display_name: called <%s>", name ? name : "NULL");
#endif
return g_strdup (name);
}
