/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_hbutton_box_get_properties (GtkWidget * widget, GbWidgetGetArgData * data)
{
GtkButtonBoxStyle layout;
gint i, spacing;
gboolean spacing_visible = FALSE;
if (data->action != GB_SAVING)
gb_widget_output_int (data, Size, g_list_length (GTK_BOX (widget)->children));
layout = gtk_button_box_get_layout (GTK_BUTTON_BOX (widget));
for (i = 0; i < sizeof (GbLayoutValues) / sizeof (GbLayoutValues[0]); i++)
{
if (GbLayoutValues[i] == layout)
gb_widget_output_choice (data, Layout, i, GbLayoutSymbols[i]);
}
if (!gb_hbutton_box_is_dialog_action_area (widget))
{
spacing_visible = TRUE;
spacing = gtk_box_get_spacing (GTK_BOX (widget));
gb_widget_output_int (data, Spacing, spacing);
}
if (data->action == GB_SHOWING)
{
property_set_visible (Spacing, spacing_visible);
}
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_gnome_pixmap_get_properties (GtkWidget *widget, GbWidgetGetArgData * data)
{
gboolean scaled;
gint w, h;
gb_widget_output_pixmap_filename (data, Filename,
gtk_object_get_data (GTK_OBJECT (widget),
Filename));
scaled = gtk_object_get_data (GTK_OBJECT (widget), Scaled) != NULL
? TRUE : FALSE;
if (data->action == GB_SHOWING)
{
gb_widget_output_bool (data, Scaled, scaled);
property_set_sensitive (Width, scaled);
property_set_sensitive (Height, scaled);
}
/* We only save the scaled width and height if the pixmap is scaled. */
w = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), Width));
if (scaled || data->action == GB_SHOWING)
gb_widget_output_int (data, Width, w);
h = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), Height));
if (scaled || data->action == GB_SHOWING)
gb_widget_output_int (data, Height, h);
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_custom_get_properties (GtkWidget *widget, GbWidgetGetArgData * data)
{
gchar *string1, *string2;
gb_widget_output_string (data, CreationFunction, gtk_object_get_data (GTK_OBJECT (widget), CreationFunction));
string1 = gtk_object_get_data (GTK_OBJECT (widget), String1);
string2 = gtk_object_get_data (GTK_OBJECT (widget), String2);
/* For empty strings output NULL (i.e. don't save in the XML). */
if (string1 && *string1 == '\0')
string1 = NULL;
if (string2 && *string2 == '\0')
string2 = NULL;
gb_widget_output_string (data, String1, string1);
gb_widget_output_string (data, String2, string2);
gb_widget_output_int (data, Int1, GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), Int1)));
gb_widget_output_int (data, Int2, GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), Int2)));
/* When saving we also save the last modification time. */
if (data->action == GB_SAVING)
{
time_t last_mod_time;
last_mod_time = gb_custom_get_last_mod_time (widget);
if (last_mod_time != 0)
{
save_date (data, LastModTime, last_mod_time);
}
}
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_vbox_get_properties (GtkWidget * widget, GbWidgetGetArgData * data)
{
if (data->action != GB_SAVING)
gb_widget_output_int (data, Size, g_list_length (GTK_BOX (widget)->children));
gb_widget_output_bool (data, Homogeneous, GTK_BOX (widget)->homogeneous);
gb_widget_output_int (data, Spacing, GTK_BOX (widget)->spacing);
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_tclist_get_properties (GtkWidget * widget, GtkWidget *child, GbWidgetGetArgData * data)
{
gchar buffer[1024];
gchar *pos;
gboolean buffer_overrun = FALSE;
gint i;
if (data->action == GB_SAVING)
{
gb_widget_output_int (data, Cols, GTK_CLIST (widget)->columns);
pos = buffer;
for (i = 0; i < GTK_CLIST (widget)->columns; i++)
{
if (i == 0)
sprintf (pos, "%i", GTK_CLIST (widget)->column[i].width);
else
sprintf (pos, ",%i", GTK_CLIST (widget)->column[i].width);
pos += strlen (pos);
/* Extra check to make sure we don't overrun the buffer. */
if (pos - buffer > 1000)
{
g_warning ("Buffer overflow");
buffer_overrun = TRUE;
break;
}
}
if (!buffer_overrun)
gb_widget_output_string (data, ColumnWidths, buffer);
}
for (i = 0; i < sizeof (GbModeValues) / sizeof (GbModeValues[0]); i++)
{
if (GbModeValues[i] == GTK_CLIST (widget)->selection_mode)
gb_widget_output_choice (data, Mode, i, GbModeSymbols[i]);
}
gb_widget_output_bool (data, Titles, GTK_CLIST_SHOW_TITLES (widget));
for (i = 0; i < sizeof (GbShadowValues) / sizeof (GbShadowValues[0]); i++)
{
if (GbShadowValues[i] == GTK_CLIST (widget)->shadow_type)
gb_widget_output_choice (data, Shadow, i, GbShadowSymbols[i]);
}
#ifndef GTK_HAVE_FEATURES_1_1_4
for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i++)
{
if (GbPolicyValues[i] == GTK_CLIST (widget)->hscrollbar_policy)
gb_widget_output_choice (data, HPolicy, i, GbPolicySymbols[i]);
}
for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i++)
{
if (GbPolicyValues[i] == GTK_CLIST (widget)->vscrollbar_policy)
gb_widget_output_choice (data, VPolicy, i, GbPolicySymbols[i]);
}
#endif
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_file_chooser_button_get_properties (GtkWidget *widget, GbWidgetGetArgData * data)
{
gchar *title;
GtkFileChooserAction action;
gboolean local_only, show_hidden, confirm;
gint i, width_chars;
g_object_get (widget,
"title", &title,
"action", &action,
"local_only", &local_only,
"show_hidden", &show_hidden,
"do_overwrite_confirmation", &confirm,
"width_chars", &width_chars,
NULL);
gb_widget_output_translatable_string (data, Title, title);
g_free (title);
for (i = 0; i < sizeof (GbActionValues) / sizeof (GbActionValues[0]); i++)
{
if (GbActionValues[i] == action)
gb_widget_output_choice (data, Action, i, GbActionSymbols[i]);
}
gb_widget_output_bool (data, LocalOnly, local_only);
gb_widget_output_bool (data, ShowHidden, show_hidden);
gb_widget_output_bool (data, Confirm, confirm);
gb_widget_output_int (data, WidthChars, width_chars);
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_spin_button_get_properties (GtkWidget * widget, GbWidgetGetArgData * data)
{
gint i, update_policy;
gb_widget_output_float (data, ClimbRate, GTK_SPIN_BUTTON (widget)->climb_rate);
gb_widget_output_int (data, Digits, GTK_SPIN_BUTTON (widget)->digits);
gb_widget_output_bool (data, Numeric, GTK_SPIN_BUTTON (widget)->numeric);
/* This is a slight kludge since the spin_button's update policy is
a set of flags rather than integer values */
update_policy = GTK_SPIN_BUTTON (widget)->update_policy
& (GTK_UPDATE_ALWAYS | GTK_UPDATE_IF_VALID);
for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i++)
{
if (GbPolicyValues[i] == update_policy)
gb_widget_output_choice (data, Policy, i, GbPolicySymbols[i]);
}
/* In GTK 1.1 snap_to_ticks is given its own variable. */
gb_widget_output_bool (data, Snap, GTK_SPIN_BUTTON (widget)->snap_to_ticks);
gb_widget_output_bool (data, Wrap, GTK_SPIN_BUTTON (widget)->wrap);
gb_widget_output_adjustment (data, Values,
GTK_SPIN_BUTTON (widget)->adjustment,
"adjustment");
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_gnome_icon_entry_get_properties (GtkWidget *widget, GbWidgetGetArgData * data)
{
gb_widget_output_translatable_string (data, Title, gtk_object_get_data (GTK_OBJECT (widget), Title));
gb_widget_output_string (data, HistoryID, gtk_object_get_data (GTK_OBJECT (widget), HistoryID));
gb_widget_output_int (data, MaxSaved, GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), MaxSaved)));
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_option_menu_get_properties (GtkWidget * widget, GbWidgetGetArgData * data)
{
if (data->action == GB_SAVING)
gb_widget_output_int (data, History,
gtk_option_menu_get_history (GTK_OPTION_MENU (widget)));
}
/* SPECIAL CODE: "placement", "band", "position", "offset" and "behavior"
are now packing properties, so we have this special function to save
them, which is called directly in gb_widget_save(). */
void
gb_bonobo_dock_item_save_packing_properties (GtkWidget *parent,
GtkWidget *widget,
GbWidgetGetArgData * data)
{
char *behavior;
save_start_tag (data, "packing");
if (BONOBO_DOCK_ITEM (widget)->is_floating)
{
gb_widget_output_string (data, Placement, "BONOBO_DOCK_FLOATING");
}
else
{
BonoboDockPlacement placement;
gint band_num, position, offset, idx;
if (gb_bonobo_dock_item_find_position (BONOBO_DOCK_ITEM (widget),
&placement, &band_num,
&position, &offset))
{
idx = glade_util_int_array_index (GladePlacementValues,
GladePlacementSize,
placement);
if (idx != -1)
gb_widget_output_string (data, Placement,
GladePlacementSymbols[idx]);
gb_widget_output_int (data, BandNum, band_num);
gb_widget_output_int (data, Position, position);
gb_widget_output_int (data, Offset, offset);
}
else
{
g_warning ("Dock band not found");
}
}
behavior = glade_util_string_from_flags (BONOBO_TYPE_DOCK_ITEM_BEHAVIOR,
BONOBO_DOCK_ITEM (widget)->behavior);
save_string (data, Behavior, behavior);
g_free (behavior);
save_end_tag (data, "packing");
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_vbutton_box_get_properties (GtkWidget * widget, GbWidgetGetArgData * data)
{
GtkButtonBoxStyle layout;
gint i, spacing;
if (data->action != GB_SAVING)
gb_widget_output_int (data, Size, g_list_length (GTK_BOX (widget)->children));
layout = gtk_button_box_get_layout (GTK_BUTTON_BOX (widget));
for (i = 0; i < sizeof (GbLayoutValues) / sizeof (GbLayoutValues[0]); i++)
{
if (GbLayoutValues[i] == layout)
gb_widget_output_choice (data, Layout, i, GbLayoutSymbols[i]);
}
spacing = gtk_box_get_spacing (GTK_BOX (widget));
gb_widget_output_int (data, Spacing, spacing);
}
/* Shows or saves the child properties of a child of a GtkFixed. */
void
gb_fixed_get_child_properties (GtkWidget *widget, GtkWidget *child,
GbWidgetGetArgData *data)
{
gint x, y;
if (data->action == GB_SAVING)
save_start_tag (data, "packing");
gtk_container_child_get (GTK_CONTAINER (widget), child,
"x", &x,
"y", &y,
NULL);
gb_widget_output_int (data, GladeFixedChildX, x);
gb_widget_output_int (data, GladeFixedChildY, y);
if (data->action == GB_SAVING)
save_end_tag (data, "packing");
}
void
gb_box_get_child_properties (GtkWidget *widget, GtkWidget *child,
GbWidgetGetArgData *data)
{
gboolean expand, fill;
gint position;
guint padding;
GtkPackType pack_type;
if (data->action == GB_SAVING)
save_start_tag (data, "packing");
if (data->action == GB_SHOWING)
{
position = glade_util_get_box_pos (GTK_BOX (widget), child);
gb_widget_output_int (data, GbPosition, position);
}
gtk_box_query_child_packing (GTK_BOX (widget), child,
&expand, &fill, &padding, &pack_type);
gb_widget_output_int (data, GbPadding, padding);
gb_widget_output_bool (data, GbExpand, expand);
gb_widget_output_bool (data, GbFill, fill);
if (data->action == GB_SAVING)
{
/* Save pack type as an enum symbol rather than a bool */
if (pack_type == GTK_PACK_END)
{
gb_widget_output_string (data, GbPack, "GTK_PACK_END");
}
}
else
{
gb_widget_output_bool (data, GbPack, pack_type == GTK_PACK_START);
}
if (data->action == GB_SAVING)
save_end_tag (data, "packing");
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_option_menu_get_properties (GtkWidget * widget, GbWidgetGetArgData * data)
{
GbAddLabelData add_label_data;
gchar items[ITEMS_BUFFER_SIZE];
/* Clear the buffer and make sure it's seen as valid */
items[0] = '\0';
add_label_data.items = items;
add_label_data.option_menu = widget;
add_label_data.buffer_overflow = FALSE;
add_label_data.index = 0;
add_label_data.selected_index = 0;
gtk_container_foreach (GTK_CONTAINER (GTK_OPTION_MENU (widget)->menu),
(GtkCallback) add_label, &add_label_data);
if (add_label_data.buffer_overflow)
{
gb_widget_output_text (data, Items, "");
gb_widget_output_int (data, Choice, 0);
if (data->action == GB_SHOWING)
{
property_set_sensitive (Items, FALSE);
property_set_sensitive (Choice, FALSE);
}
}
else
{
gb_widget_output_translatable_text_in_lines (data, Items, items);
gb_widget_output_int (data, Choice, add_label_data.selected_index);
if (data->action == GB_SHOWING)
{
property_set_sensitive (Items, TRUE);
property_set_sensitive (Choice, TRUE);
}
}
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_vbutton_box_get_properties (GtkWidget * widget, GbWidgetGetArgData * data)
{
GtkButtonBoxStyle layout;
gint i, spacing, min_width, min_height, ipad_x, ipad_y;
gint default_spacing;
gint default_min_width, default_min_height, default_ipad_x, default_ipad_y;
if (data->action != GB_SAVING)
gb_widget_output_int (data, Size, g_list_length (GTK_BOX (widget)->children));
layout = gtk_button_box_get_layout (GTK_BUTTON_BOX (widget));
for (i = 0; i < sizeof (GbLayoutValues) / sizeof (GbLayoutValues[0]); i++)
{
if (GbLayoutValues[i] == layout)
gb_widget_output_choice (data, Layout, i, GbLayoutSymbols[i]);
}
spacing = gtk_button_box_get_spacing (GTK_BUTTON_BOX (widget));
default_spacing = gtk_vbutton_box_get_spacing_default ();
if (spacing == GTK_BUTTONBOX_DEFAULT)
spacing = default_spacing;
gb_widget_output_int (data, Spacing, spacing);
gtk_button_box_get_child_size_default (&default_min_width,
&default_min_height);
gtk_button_box_get_child_size (GTK_BUTTON_BOX (widget), &min_width,
&min_height);
if (min_width == GTK_BUTTONBOX_DEFAULT)
min_width = default_min_width;
if (min_height == GTK_BUTTONBOX_DEFAULT)
min_height = default_min_height;
gb_widget_output_int (data, Width, min_width);
gb_widget_output_int (data, Height, min_height);
gtk_button_box_get_child_ipadding_default (&default_ipad_x, &default_ipad_y);
gtk_button_box_get_child_ipadding (GTK_BUTTON_BOX (widget), &ipad_x, &ipad_y);
if (ipad_x == GTK_BUTTONBOX_DEFAULT)
ipad_x = default_ipad_x;
if (ipad_y == GTK_BUTTONBOX_DEFAULT)
ipad_y = default_ipad_y;
gb_widget_output_int (data, XPad, ipad_x);
gb_widget_output_int (data, YPad, ipad_y);
}
void
gb_label_get_standard_properties (GtkWidget * widget,
GbWidgetGetArgData * data,
const char *label_p,
const char *use_underline_p,
const char *use_markup_p,
const char *justify_p,
const char *wrap_p,
const char *selectable_p,
const char *xalign_p,
const char *yalign_p,
const char *xpad_p,
const char *ypad_p,
const char *focus_target_p)
{
const gchar *label_text;
gint i;
label_text = gtk_label_get_label (GTK_LABEL (widget));
gb_widget_output_translatable_text (data, label_p, label_text);
gb_widget_output_bool (data, use_underline_p,
gtk_label_get_use_underline (GTK_LABEL (widget)));
gb_widget_output_bool (data, use_markup_p,
GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), use_markup_p)));
for (i = 0; i < sizeof (GbJustifyValues) / sizeof (GbJustifyValues[0]); i++)
{
if (GbJustifyValues[i] == GTK_LABEL (widget)->jtype)
gb_widget_output_choice (data, justify_p, i, GbJustifySymbols[i]);
}
gb_widget_output_bool (data, wrap_p, GTK_LABEL (widget)->wrap);
gb_widget_output_bool (data, selectable_p,
gtk_label_get_selectable (GTK_LABEL (widget)));
gb_widget_output_float (data, xalign_p, GTK_MISC (widget)->xalign);
gb_widget_output_float (data, yalign_p, GTK_MISC (widget)->yalign);
gb_widget_output_int (data, xpad_p, GTK_MISC (widget)->xpad);
gb_widget_output_int (data, ypad_p, GTK_MISC (widget)->ypad);
/* Labels not in buttons may have a focus target widget. */
if (!gb_label_find_mnemonic_widget (widget))
{
gchar *accel_target;
accel_target = gtk_object_get_data (GTK_OBJECT (widget), focus_target_p);
/* If we're showing we need to display the list of possible focus target
widgets. We walk the tree of widgets in this component, and if a
widget has CAN_FOCUS set, we add it to the list. */
if (data->action == GB_SHOWING)
{
GList *focus_targets = NULL, *standard_items = NULL;
GtkWidget *item, *combo;
property_set_visible (focus_target_p, TRUE);
gb_label_get_focus_targets (gtk_widget_get_toplevel (widget),
&focus_targets);
property_set_combo_strings (focus_target_p, focus_targets);
g_list_free (focus_targets);
combo = property_get_value_widget (focus_target_p);
item = gtk_list_item_new_with_label (_("Auto"));
gtk_widget_show (item);
standard_items = g_list_append (standard_items, item);
item = gtk_list_item_new ();
gtk_widget_set_sensitive (item, FALSE);
gtk_widget_show (item);
standard_items = g_list_append (standard_items, item);
gtk_combo_set_item_string (GTK_COMBO (combo), GTK_ITEM (item), "");
gtk_list_prepend_items (GTK_LIST (GTK_COMBO (combo)->list),
standard_items);
if (!accel_target)
{
accel_target = _("Auto");
}
gb_widget_output_combo (data, focus_target_p, accel_target);
}
else
{
/* When saving, we only save the property if it has been set. */
if (accel_target)
{
/* First check that the widget is still there, and if it isn't
just skip it. */
if (glade_util_find_widget (gtk_widget_get_toplevel (widget),
accel_target))
{
gb_widget_output_combo (data, focus_target_p, accel_target);
}
}
else
{
/* If no target has been set, and the label has an underlined
key, we try to find a default target and save that. */
if (gtk_label_get_use_underline (GTK_LABEL (widget)))
{
GtkWidget *accel_target;
accel_target = glade_util_find_default_accelerator_target (widget);
if (accel_target)
{
gb_widget_output_string (data, focus_target_p, gtk_widget_get_name (accel_target));
}
}
}
}
}
else
{
if (data->action == GB_SHOWING)
{
property_set_visible (focus_target_p, FALSE);
}
}
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_bonobo_control_get_properties (GtkWidget * widget, GbWidgetGetArgData * data)
{
Bonobo_PropertyBag pb = control_get_pb (widget);
char *moniker = gtk_object_get_data (GTK_OBJECT (widget), Moniker);
GList *key_list, *names;
g_assert (moniker);
if (!pb)
return;
/* We save the moniker in the XML, though we don't show it in the property
editor. */
if (data->action == GB_SAVING)
{
save_string (data, Moniker, moniker);
}
key_list = bonobo_pbclient_get_keys (pb, NULL);
for (names = key_list; names; names = names->next) {
CORBA_TypeCode tc;
char *prop = create_prop_name (moniker, names->data);
tc = bonobo_pbclient_get_type (pb, names->data, NULL);
switch (tc->kind) {
case CORBA_tk_boolean:
gb_widget_output_bool (data, prop,
bonobo_pbclient_get_boolean (pb, names->data, NULL));
break;
case CORBA_tk_string:
{
char *str = bonobo_pbclient_get_string (pb, names->data, NULL);
gb_widget_output_translatable_string (data, prop, str);
g_free (str);
break;
}
case CORBA_tk_ulong:
gb_widget_output_int (data, prop,
bonobo_pbclient_get_ulong (pb, names->data, NULL));
break;
case CORBA_tk_long:
gb_widget_output_int (data, prop,
bonobo_pbclient_get_long (pb, names->data, NULL));
break;
case CORBA_tk_short:
gb_widget_output_int (data, prop,
bonobo_pbclient_get_short (pb, names->data, NULL));
break;
case CORBA_tk_ushort:
gb_widget_output_int (data, prop,
bonobo_pbclient_get_ushort (pb, names->data, NULL));
break;
case CORBA_tk_float:
gb_widget_output_float (data, prop,
bonobo_pbclient_get_float (pb, names->data, NULL));
break;
case CORBA_tk_double:
gb_widget_output_float (data, prop,
bonobo_pbclient_get_double (pb, names->data, NULL));
break;
default:
g_warning ("Unhandled type %d", tc->kind);
break;
}
g_free (prop);
}
bonobo_pbclient_free_keys (key_list);
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_image_get_properties (GtkWidget * widget, GbWidgetGetArgData * data)
{
gchar *icon = gtk_object_get_data (GTK_OBJECT (widget), GladeIconKey);
gchar *icon_name = NULL;
gboolean is_stock_icon, is_named_icon = FALSE;
gint i, pixel_size;
GtkImageType storage_type;
storage_type = gtk_image_get_storage_type (GTK_IMAGE (widget));
pixel_size = gtk_image_get_pixel_size (GTK_IMAGE (widget));
is_stock_icon = glade_util_check_is_stock_id (icon);
if (storage_type == GTK_IMAGE_ICON_NAME)
{
g_object_get (widget,
"icon_name", &icon_name,
NULL);
if (icon_name && *icon_name)
is_named_icon = TRUE;
}
if (data->action == GB_SAVING)
{
/* When saving we want to use "stock" or "pixbuf", depending on whether
it is a stock icon or an oridinary pixmap file. */
if (is_stock_icon)
gb_widget_output_icon (data, "stock", icon);
else
gb_widget_output_icon (data, "pixbuf", icon);
}
else
{
gb_widget_output_icon (data, Icon, icon);
}
if (is_stock_icon || is_named_icon)
{
if (data->action == GB_SHOWING)
{
for (i = 0; i < GladeIconSizeChoicesSize; i++)
{
if (GladeIconSizeValues[i] == GTK_IMAGE (widget)->icon_size)
gb_widget_output_choice (data, IconSize, i,
GladeIconSizeSymbols[i]);
}
check_visible_sizes (icon, is_named_icon);
}
else
{
/* We have to save the size as an integer, which sucks a bit.
The integer is the GtkIconSize enum value, not the actual size.*/
if (is_stock_icon || pixel_size == -1)
gb_widget_output_int (data, IconSize,
GTK_IMAGE (widget)->icon_size);
}
}
gb_widget_output_named_icon (data, IconName, icon_name);
/* The icon size only applies to stock icons or named icons.
The pixel size only applies to named icons. */
if (data->action == GB_SHOWING)
{
property_set_sensitive (IconSize, is_stock_icon || is_named_icon);
property_set_sensitive (PixelSize, is_named_icon);
}
/* We only want to save the pixel size for named icons, and only if it is
not -1. */
if (data->action == GB_SHOWING
|| (storage_type == GTK_IMAGE_ICON_NAME && pixel_size != -1))
gb_widget_output_int (data, PixelSize, pixel_size);
gb_widget_output_float (data, XAlign, GTK_MISC (widget)->xalign);
gb_widget_output_float (data, YAlign, GTK_MISC (widget)->yalign);
gb_widget_output_int (data, XPad, GTK_MISC (widget)->xpad);
gb_widget_output_int (data, YPad, GTK_MISC (widget)->ypad);
}
