/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_handle_box_set_properties(GtkWidget *widget, GbWidgetSetArgData *data) { gchar *shadow, *position, *snap_edge; gint i; shadow = gb_widget_input_choice (data, Shadow); if (data->apply) { for (i = 0; i < sizeof (GbShadowValues) / sizeof (GbShadowValues[0]); i++) { if (!strcmp (shadow, GbShadowChoices[i]) || !strcmp (shadow, GbShadowSymbols[i])) { gtk_handle_box_set_shadow_type (GTK_HANDLE_BOX (widget), GbShadowValues[i]); break; } } } position = gb_widget_input_choice (data, Position); if (data->apply) { for (i = 0; i < sizeof (GbPositionValues) / sizeof (GbPositionValues[0]); i++) { if (!strcmp (position, GbPositionChoices[i]) || !strcmp (position, GbPositionSymbols[i])) { gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (widget), GbPositionValues[i]); break; } } } snap_edge = gb_widget_input_choice (data, SnapEdge); if (data->apply) { for (i = 0; i < sizeof (GbPositionValues) / sizeof (GbPositionValues[0]); i++) { if (!strcmp (snap_edge, GbPositionChoices[i]) || !strcmp (snap_edge, GbPositionSymbols[i])) { gtk_handle_box_set_snap_edge (GTK_HANDLE_BOX (widget), GbPositionValues[i]); break; } } } }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_viewport_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gint i; gchar *shadow; shadow = gb_widget_input_choice (data, Shadow); if (data->apply) { for (i = 0; i < sizeof (GbShadowValues) / sizeof (GbShadowValues[0]); i ++) { if (!strcmp (shadow, GbShadowChoices[i]) || !strcmp (shadow, GbShadowSymbols[i])) { gtk_viewport_set_shadow_type (GTK_VIEWPORT (widget), GbShadowValues [i]); break; } } } /* if (gb_widget_input_adjustment(data, HValues, GTK_VIEWPORT(widget)->hadjustment)) gtk_signal_emit_by_name (GTK_OBJECT (GTK_VIEWPORT(widget)->hadjustment), "value_changed"); if (gb_widget_input_adjustment(data, VValues, GTK_VIEWPORT(widget)->vadjustment)) gtk_signal_emit_by_name (GTK_OBJECT (GTK_VIEWPORT(widget)->vadjustment), "value_changed"); */ }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_spin_button_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gfloat climb_rate; gint digits, policy_value = GTK_UPDATE_ALWAYS, i; gchar *policy; gboolean numeric, snap, wrap; GtkAdjustment *adj; climb_rate = gb_widget_input_float (data, ClimbRate); /* No set function for this */ if (data->apply) GTK_SPIN_BUTTON (widget)->climb_rate = climb_rate; digits = gb_widget_input_int (data, Digits); if (data->apply) gtk_spin_button_set_digits (GTK_SPIN_BUTTON (widget), digits); numeric = gb_widget_input_bool (data, Numeric); if (data->apply) gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (widget), numeric); snap = gb_widget_input_bool (data, Snap); if (data->apply) gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (widget), snap); policy = gb_widget_input_choice (data, Policy); for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i++) { if (!strcmp (policy, GbPolicyChoices[i]) || !strcmp (policy, GbPolicySymbols[i])) { policy_value = GbPolicyValues[i]; break; } } if (data->apply) gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (widget), policy_value); wrap = gb_widget_input_bool (data, Wrap); if (data->apply) gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (widget), wrap); adj = GTK_SPIN_BUTTON (widget)->adjustment; if (gb_widget_input_adjustment (data, Values, adj, "adjustment")) { gtk_signal_emit_by_name (GTK_OBJECT (adj), "value_changed"); } }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_hbutton_box_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gint size, i, spacing; gchar *layout; gboolean queue_resize = FALSE; if (data->action != GB_LOADING) { size = gb_widget_input_int (data, Size); if (data->apply) gb_box_set_size (widget, size); } layout = gb_widget_input_choice (data, Layout); if (data->apply) { for (i = 0; i < sizeof (GbLayoutValues) / sizeof (GbLayoutValues[0]); i++) { if (!strcmp (layout, GbLayoutChoices[i]) || !strcmp (layout, GbLayoutSymbols[i])) { gtk_button_box_set_layout (GTK_BUTTON_BOX (widget), GbLayoutValues [i]); queue_resize = TRUE; break; } } } if (!gb_hbutton_box_is_dialog_action_area (widget)) { spacing = gb_widget_input_int (data, Spacing); if (data->apply) { gtk_box_set_spacing (GTK_BOX (widget), spacing); queue_resize = TRUE; } } if (queue_resize) gtk_widget_queue_resize (widget); }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_file_chooser_button_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gchar *title, *action; gboolean local_only, show_hidden, confirm; gint i, width_chars; title = gb_widget_input_string (data, Title); if (data->apply) g_object_set (widget, "title", title, NULL); action = gb_widget_input_choice (data, Action); if (data->apply) { for (i = 0; i < sizeof (GbActionValues) / sizeof (GbActionValues[0]); i++) { if (!strcmp (action, GbActionChoices[i]) || !strcmp (action, GbActionSymbols[i])) { g_object_set (widget, "action", GbActionValues[i], NULL); break; } } } local_only = gb_widget_input_bool (data, LocalOnly); if (data->apply) g_object_set (widget, "local_only", local_only, NULL); show_hidden = gb_widget_input_bool (data, ShowHidden); if (data->apply) g_object_set (widget, "show_hidden", show_hidden, NULL); confirm = gb_widget_input_bool (data, Confirm); if (data->apply) g_object_set (widget, "do_overwrite_confirmation", confirm, NULL); width_chars = gb_widget_input_int (data, WidthChars); if (data->apply) g_object_set (widget, "width_chars", width_chars, NULL); }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_gnome_message_box_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { GtkWidget *pixmap, *label; gchar *message, *type_name; gboolean auto_close, hide_on_close; get_message_box_widgets (widget, &pixmap, &label); g_return_if_fail (pixmap != NULL); g_return_if_fail (label != NULL); type_name = gb_widget_input_choice (data, MessageBoxType); if (data->apply) { set_message_box_type (widget, pixmap, type_name); } message = gb_widget_input_text (data, Message); if (data->apply) { gtk_label_set_text (GTK_LABEL (label), message); } if (data->action == GB_APPLYING) g_free (message); gb_window_set_standard_properties (widget, data, Title, NULL, Position, Modal, DefaultWidth, DefaultHeight, Shrink, Grow, AutoShrink, WMName, WMClass); auto_close = gb_widget_input_bool (data, AutoClose); if (data->apply) gnome_dialog_set_close (GNOME_DIALOG (widget), auto_close); hide_on_close = gb_widget_input_bool (data, HideOnClose); if (data->apply) gnome_dialog_close_hides (GNOME_DIALOG (widget), hide_on_close); }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_scrolled_window_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gint i; gchar *hpolicy, *vpolicy, *hupdate_policy, *vupdate_policy; gboolean set_policy = FALSE; GtkPolicyType hpolicy_value = GTK_POLICY_AUTOMATIC; GtkPolicyType vpolicy_value = GTK_POLICY_AUTOMATIC; GtkUpdateType hupdate_policy_value = GTK_UPDATE_CONTINUOUS; GtkUpdateType vupdate_policy_value = GTK_UPDATE_CONTINUOUS; gchar *shadow, *placement; hpolicy = gb_widget_input_choice (data, HPolicy); if (data->apply) { set_policy = TRUE; for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i++) { if (!strcmp (hpolicy, GbPolicyChoices[i]) || !strcmp (hpolicy, GbPolicySymbols[i])) hpolicy_value = GbPolicyValues[i]; } } else hpolicy_value = GTK_SCROLLED_WINDOW (widget)->hscrollbar_policy; vpolicy = gb_widget_input_choice (data, VPolicy); if (data->apply) { set_policy = TRUE; for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i++) { if (!strcmp (vpolicy, GbPolicyChoices[i]) || !strcmp (vpolicy, GbPolicySymbols[i])) vpolicy_value = GbPolicyValues[i]; } } else vpolicy_value = GTK_SCROLLED_WINDOW (widget)->vscrollbar_policy; if (set_policy) gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), hpolicy_value, vpolicy_value); shadow = gb_widget_input_choice (data, ShadowType); if (data->apply) { for (i = 0; i < GladeShadowChoicesSize; i++) { if (!strcmp (shadow, GladeShadowChoices[i]) || !strcmp (shadow, GladeShadowSymbols[i])) { gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GladeShadowValues[i]); break; } } } placement = gb_widget_input_choice (data, WindowPlacement); if (data->apply) { for (i = 0; i < GladeCornerChoicesSize; i++) { if (!strcmp (placement, GladeCornerChoices[i]) || !strcmp (placement, GladeCornerSymbols[i])) { gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (widget), GladeCornerValues[i]); break; } } } }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_tclist_set_properties (GtkWidget * widget, GtkWidget *child, GbWidgetSetArgData * data) { gchar *widths, *pos, *mode; gchar *shadow; gboolean titles; gint col, w, i; #ifndef GTK_HAVE_FEATURES_1_1_4 gboolean myApply; gchar *hpolicy, *vpolicy; GtkPolicyType hpolicy_value = GTK_POLICY_AUTOMATIC; GtkPolicyType vpolicy_value = GTK_POLICY_AUTOMATIC; #endif if (data->action == GB_LOADING) { widths = gb_widget_input_string (data, ColumnWidths); if (data->apply) { pos = widths; for (col = 0; col < GTK_CLIST (widget)->columns; col++) { w = atoi (pos); gtk_clist_set_column_width (GTK_CLIST (widget), col, w); pos = strchr (pos, ','); if (!pos) break; pos++; } } } mode = gb_widget_input_choice (data, Mode); if (data->apply) { for (i = 0; i < sizeof (GbModeValues) / sizeof (GbModeValues[0]); i++) { if (!strcmp (mode, GbModeChoices[i]) || !strcmp (mode, GbModeSymbols[i])) { gtk_clist_set_selection_mode (GTK_CLIST (widget), GbModeValues[i]); break; } } } titles = gb_widget_input_bool (data, Titles); if (data->apply) { if (titles) gtk_clist_column_titles_show (GTK_CLIST (widget)); else gtk_clist_column_titles_hide (GTK_CLIST (widget)); } shadow = gb_widget_input_choice (data, Shadow); if (data->apply) { for (i = 0; i < sizeof (GbShadowValues) / sizeof (GbShadowValues[0]); i ++) { if (!strcmp (shadow, GbShadowChoices[i]) || !strcmp (shadow, GbShadowSymbols[i])) { #ifdef GTK_HAVE_FEATURES_1_1_4 gtk_clist_set_shadow_type (GTK_CLIST (widget), GbShadowValues[i]); #else gtk_clist_set_border (GTK_CLIST (widget), GbShadowValues[i]); #endif break; } } } #ifndef GTK_HAVE_FEATURES_1_1_4 hpolicy = gb_widget_input_choice (data, HPolicy); myApply = data->apply; vpolicy = gb_widget_input_choice (data, VPolicy); if (data->apply || myApply) { for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i ++) { if (!strcmp (hpolicy, GbPolicyChoices[i]) || !strcmp (hpolicy, GbPolicySymbols[i])) hpolicy_value = GbPolicyValues[i]; if (!strcmp (vpolicy, GbPolicyChoices[i]) || !strcmp (vpolicy, GbPolicySymbols[i])) vpolicy_value = GbPolicyValues[i]; } gtk_clist_set_policy (GTK_CLIST (widget), vpolicy_value, hpolicy_value); } #endif }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ void gb_label_set_standard_properties (GtkWidget * widget, GbWidgetSetArgData * 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) { gchar *label, *justify, *accel_target; const gchar *label_text; gfloat xalign, yalign; gint xpad, ypad, i; gboolean wrap, selectable, set_alignment = FALSE, set_padding = FALSE; gboolean use_underline, use_markup; gboolean set_label = FALSE; use_underline = gb_widget_input_bool (data, use_underline_p); if (data->apply) gtk_label_set_use_underline (GTK_LABEL (widget), use_underline); use_markup = gb_widget_input_bool (data, use_markup_p); if (data->apply) { set_label = TRUE; gtk_object_set_data (GTK_OBJECT (widget), use_markup_p, GINT_TO_POINTER (use_markup)); } label = gb_widget_input_text (data, label_p); if (data->apply) { set_label = TRUE; label_text = label; } else { label_text = gtk_label_get_label (GTK_LABEL (widget)); } if (set_label) { gboolean prev_use_markup; use_markup = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), use_markup_p)); /* We try to parse the markup here, and if it isn't valid, we will turn use_markup off and show it as plain text. */ if (use_markup) { GError *error = NULL; gunichar accel_marker = 0; PangoAttrList *attrs = NULL; gunichar accel_char = 0; gchar *text = NULL; if (gtk_label_get_use_underline (GTK_LABEL (widget))) accel_marker = '_'; /* We check it is valid markup. If it isn't we will set "use_markup" to FALSE. Note that we don't need attrs, text, or accel_char but it seems to crash otherwise. */ if (!pango_parse_markup (label_text, -1, accel_marker, &attrs, &text, &accel_char, &error)) { use_markup = FALSE; g_error_free (error); } else { if (attrs) pango_attr_list_unref (attrs); g_free (text); } } /* If we are turning use_markup off, we want to do that before setting the text. If we are turning it on, we want to do it after. */ prev_use_markup = gtk_label_get_use_markup (GTK_LABEL (widget)); if (!use_markup && prev_use_markup) gtk_label_set_use_markup (GTK_LABEL (widget), use_markup); gtk_label_set_label (GTK_LABEL (widget), label_text); if (use_markup && !prev_use_markup) gtk_label_set_use_markup (GTK_LABEL (widget), use_markup); } if (data->action == GB_APPLYING) g_free (label); justify = gb_widget_input_choice (data, justify_p); if (data->apply) { for (i = 0; i < sizeof (GbJustifyValues) / sizeof (GbJustifyValues[0]); i++) { if (!strcmp (justify, GbJustifyChoices[i]) || !strcmp (justify, GbJustifySymbols[i])) { gtk_label_set_justify (GTK_LABEL (widget), GbJustifyValues[i]); break; } } } wrap = gb_widget_input_bool (data, wrap_p); if (data->apply) gtk_label_set_line_wrap (GTK_LABEL (widget), wrap); selectable = gb_widget_input_bool (data, selectable_p); if (data->apply) gtk_label_set_selectable (GTK_LABEL (widget), selectable); xalign = gb_widget_input_float (data, xalign_p); if (data->apply) set_alignment = TRUE; else xalign = GTK_MISC (widget)->xalign; yalign = gb_widget_input_float (data, yalign_p); if (data->apply) set_alignment = TRUE; else yalign = GTK_MISC (widget)->yalign; if (set_alignment) gtk_misc_set_alignment (GTK_MISC (widget), xalign, yalign); xpad = gb_widget_input_int (data, xpad_p); if (data->apply) set_padding = TRUE; else xpad = GTK_MISC (widget)->xpad; ypad = gb_widget_input_int (data, ypad_p); if (data->apply) set_padding = TRUE; else ypad = GTK_MISC (widget)->ypad; if (set_padding) gtk_misc_set_padding (GTK_MISC (widget), xpad, ypad); /* Labels not in buttons may have a focus target widget. */ accel_target = gb_widget_input_combo (data, focus_target_p); if (data->apply) { if (!gb_label_find_mnemonic_widget (widget)) { if (!strcmp (accel_target, _("Auto"))) accel_target = NULL; gtk_object_set_data_full (GTK_OBJECT (widget), focus_target_p, g_strdup (accel_target), accel_target ? g_free : NULL); } } }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_vbutton_box_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gint size, i, spacing, min_width, min_height, ipad_x, ipad_y; gchar *layout; gboolean set_child_size = FALSE, set_child_padding = FALSE; gboolean queue_resize = FALSE; size = gb_widget_input_int (data, Size); if (data->apply) gb_box_set_size (widget, size); layout = gb_widget_input_choice (data, Layout); if (data->apply) { for (i = 0; i < sizeof (GbLayoutValues) / sizeof (GbLayoutValues[0]); i ++) { if (!strcmp (layout, GbLayoutChoices[i]) || !strcmp (layout, GbLayoutSymbols[i])) { gtk_button_box_set_layout (GTK_BUTTON_BOX (widget), GbLayoutValues [i]); queue_resize = TRUE; break; } } } spacing = gb_widget_input_int (data, Spacing); if (data->apply) { gtk_button_box_set_spacing (GTK_BUTTON_BOX (widget), spacing); queue_resize = TRUE; } min_width = gb_widget_input_int (data, Width); if (data->apply) set_child_size = TRUE; else min_width = GTK_BUTTON_BOX (widget)->child_min_width; min_height = gb_widget_input_int (data, Height); if (data->apply) set_child_size = TRUE; else min_height = GTK_BUTTON_BOX (widget)->child_min_height; if (set_child_size) { gtk_button_box_set_child_size (GTK_BUTTON_BOX (widget), min_width, min_height); queue_resize = TRUE; } ipad_x = gb_widget_input_int (data, XPad); if (data->apply) set_child_padding = TRUE; else ipad_x = GTK_BUTTON_BOX (widget)->child_ipad_x; ipad_y = gb_widget_input_int (data, YPad); if (data->apply) set_child_padding = TRUE; else ipad_y = GTK_BUTTON_BOX (widget)->child_ipad_y; if (set_child_padding) { gtk_button_box_set_child_ipadding (GTK_BUTTON_BOX (widget), ipad_x, ipad_y); queue_resize = TRUE; } if (queue_resize) gtk_widget_queue_resize (widget); }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_image_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gfloat xalign, yalign; gint xpad, ypad, i, pixel_size; gboolean set_alignment = FALSE, set_padding = FALSE, apply_icon_size; GtkIconSize icon_size = GTK_ICON_SIZE_BUTTON; gchar *icon_size_string, *icon, *icon_name; icon_size = GTK_IMAGE (widget)->icon_size; if (data->action == GB_APPLYING) { icon_size_string = gb_widget_input_choice (data, IconSize); apply_icon_size = data->apply; if (data->apply) { for (i = 0; i < GladeIconSizeChoicesSize; i++) { if (!strcmp (icon_size_string, GladeIconSizeChoices[i]) || !strcmp (icon_size_string, GladeIconSizeSymbols[i])) { icon_size = GladeIconSizeValues[i]; break; } } } } 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.*/ int new_size = gb_widget_input_int (data, IconSize); apply_icon_size = data->apply; if (data->apply) icon_size = new_size; } /* When loading we use different names. */ if (data->action == GB_LOADING) { icon = gb_widget_input_icon (data, "stock"); if (!data->apply) icon = gb_widget_input_icon (data, "pixbuf"); } else { icon = gb_widget_input_icon (data, Icon); } if (data->apply) { gboolean is_stock_icon = glade_util_check_is_stock_id (icon); /* Remove the old icon stored in the widget data, and remove the pixmap from the project, if necessary. */ gb_image_clear_pixmap (widget, data->project); gtk_object_set_data_full (GTK_OBJECT (widget), GladeIconKey, g_strdup (icon), icon ? g_free : NULL); if (is_stock_icon) { GtkIconSize new_icon_size; new_icon_size = check_icon_size (icon, icon_size); /* If we are showing this widget's properties, we need to update the sizes option menu. */ if (property_get_widget () == widget) { /* We set it sensitive before changing the value, so the child menu item is changed from insensitive to sensitive if needed. Otherwise it may remain insensitive. */ property_set_sensitive (IconSize, TRUE); property_set_sensitive (PixelSize, FALSE); property_set_auto_apply (FALSE); check_visible_sizes (icon, FALSE); /* Check the icon size is valid for the stock item, and if not pick the first valid size. */ for (i = 0; i < GladeIconSizeChoicesSize; i++) { if (GladeIconSizeValues[i] == new_icon_size) { property_set_choice (IconSize, i); } } property_set_named_icon (IconName, NULL); property_set_auto_apply (TRUE); } gtk_image_set_from_stock (GTK_IMAGE (widget), icon, new_icon_size); } else { /* If an icon filename is set, use that, otherwise use the icon we use for the palette. */ if (icon) { gtk_image_set_from_file (GTK_IMAGE (widget), icon); glade_project_add_pixmap (data->project, icon); } else { gtk_image_set_from_pixmap (GTK_IMAGE (widget), gbwidget.gdkpixmap, gbwidget.mask); } if (property_get_widget () == widget) { /* The icon size isn't relevant to non-stock icons. */ property_set_sensitive (IconSize, FALSE); property_set_sensitive (PixelSize, FALSE); property_set_auto_apply (FALSE); property_set_named_icon (IconName, NULL); property_set_auto_apply (TRUE); } } /* We've recreated the icon with the new size above, so we don't need to apply the size again. */ apply_icon_size = FALSE; } /* This is for the named/themed icon. */ icon_name = gb_widget_input_named_icon (data, IconName); if (data->apply) { /* Clear any stock icon or icon from a file. */ gb_image_clear_pixmap (widget, data->project); gtk_image_set_from_icon_name (GTK_IMAGE (widget), icon_name, icon_size); if (property_get_widget () == widget) { property_set_sensitive (IconSize, TRUE); property_set_sensitive (PixelSize, TRUE); /* Clear the Icon property. */ property_set_auto_apply (FALSE); property_set_icon (Icon, NULL); property_set_auto_apply (TRUE); } /* We've recreated the icon with the new size above, so we don't need to apply the size again. */ apply_icon_size = FALSE; } /* When we set the icon size, we reset the pixel size to -1, otherwise it overrides the icon size. */ if (apply_icon_size) { gtk_image_set_pixel_size (GTK_IMAGE (widget), -1); g_object_set (widget, "icon_size", icon_size, NULL); if (property_get_widget () == widget) { property_set_auto_apply (FALSE); property_set_int (PixelSize, -1); property_set_auto_apply (TRUE); } } /* GtkImage doesn't like a pixel size of 0 so we just skip that. */ pixel_size = gb_widget_input_int (data, PixelSize); if (data->apply && pixel_size != 0) gtk_image_set_pixel_size (GTK_IMAGE (widget), pixel_size); xalign = gb_widget_input_float (data, XAlign); if (data->apply) set_alignment = TRUE; else xalign = GTK_MISC (widget)->xalign; yalign = gb_widget_input_float (data, YAlign); if (data->apply) set_alignment = TRUE; else yalign = GTK_MISC (widget)->yalign; if (set_alignment) gtk_misc_set_alignment (GTK_MISC (widget), xalign, yalign); xpad = gb_widget_input_int (data, XPad); if (data->apply) set_padding = TRUE; else xpad = GTK_MISC (widget)->xpad; ypad = gb_widget_input_int (data, YPad); if (data->apply) set_padding = TRUE; else ypad = GTK_MISC (widget)->ypad; if (set_padding) gtk_misc_set_padding (GTK_MISC (widget), xpad, ypad); }
void gb_window_set_standard_properties (GtkWidget * widget, GbWidgetSetArgData * data, gchar *title_p, gchar *type_p, gchar *position_p, gchar *modal_p, gchar *default_width_p, gchar *default_height_p, gchar *shrink_p, gchar *grow_p, gchar *auto_shrink_p, gchar *wmname_p, gchar *wmclass_p, gchar *resizable_p, gchar *destroy_with_parent_p, gchar *icon_p) { gchar *title, *type, *position; gint default_width, default_height, i; gboolean modal, apply_default_width, apply_default_height; gboolean resizable, destroy_with_parent; #if 0 gchar *wmname, *wmclass; #endif if (title_p) { title = gb_widget_input_string (data, title_p); if (data->apply) gtk_window_set_title (GTK_WINDOW (widget), title); } if (type_p) { type = gb_widget_input_choice (data, type_p); if (data->apply) { for (i = 0; i < sizeof (GbTypeValues) / sizeof (GbTypeValues[0]); i++) { if (!strcmp (type, GbTypeChoices[i]) || !strcmp (type, GbTypeSymbols[i])) { gtk_object_set_data (GTK_OBJECT (widget), type_p, GINT_TO_POINTER (i)); break; } } } } if (position_p) { position = gb_widget_input_choice (data, position_p); if (data->apply) { for (i = 0; i < sizeof (GbPositionValues) / sizeof (GbPositionValues[0]); i++) { if (!strcmp (position, GbPositionChoices[i]) || !strcmp (position, GbPositionSymbols[i])) { gtk_object_set_data (GTK_OBJECT (widget), position_p, GINT_TO_POINTER (i)); break; } } } } if (modal_p) { modal = gb_widget_input_bool (data, modal_p); if (data->apply) { gtk_object_set_data (GTK_OBJECT (widget), modal_p, modal ? "TRUE" : NULL); } } if (default_width_p && default_height_p) { default_width = gb_widget_input_int (data, default_width_p); apply_default_width = data->apply; if (apply_default_width) { gtk_object_set_data (GTK_OBJECT (widget), DefaultWidth, GINT_TO_POINTER (default_width)); } default_height = gb_widget_input_int (data, default_height_p); apply_default_height = data->apply; if (apply_default_height) { gtk_object_set_data (GTK_OBJECT (widget), DefaultHeight, GINT_TO_POINTER (default_height)); } if (apply_default_width || apply_default_height) { if (!apply_default_width) default_width = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), DefaultWidth)); if (!apply_default_height) default_height = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), DefaultHeight)); gtk_window_set_default_size (GTK_WINDOW (widget), default_width ? default_width : -1, default_height ? default_height : -1); } } #if 0 /* These are deprecated. */ if (shrink_p && grow_p) { shrink = gb_widget_input_bool (data, shrink_p); if (data->apply) set_policy = TRUE; else shrink = GTK_WINDOW (widget)->allow_shrink; grow = gb_widget_input_bool (data, grow_p); if (data->apply) set_policy = TRUE; else grow = GTK_WINDOW (widget)->allow_grow; if (set_policy) gtk_window_set_policy (GTK_WINDOW (widget), shrink, grow, FALSE); } #endif #if 0 /* These aren't necessary, and have been used incorrectly for ages. */ if (wmname_p) { wmname = gb_widget_input_string (data, wmname_p); if (wmname && wmname[0] == '\0') wmname = NULL; if (data->apply) { gtk_object_set_data_full (GTK_OBJECT (widget), wmname_p, g_strdup (wmname), wmname ? g_free : NULL); } } if (wmclass_p) { wmclass = gb_widget_input_string (data, wmclass_p); if (wmclass && wmclass[0] == '\0') wmclass = NULL; if (data->apply) { gtk_object_set_data_full (GTK_OBJECT (widget), wmclass_p, g_strdup (wmclass), wmclass ? g_free : NULL); } } #endif if (resizable_p) { resizable = gb_widget_input_bool (data, resizable_p); if (data->apply) gtk_window_set_resizable (GTK_WINDOW (widget), resizable); } if (destroy_with_parent_p) { destroy_with_parent = gb_widget_input_bool (data, destroy_with_parent_p); if (data->apply) gtk_window_set_destroy_with_parent (GTK_WINDOW (widget), destroy_with_parent); } if (icon_p) { char *filename = gb_widget_input_pixmap_filename (data, icon_p); if (data->apply) { char *old_filename; if (filename && filename[0] == '\0') filename = NULL; /* Remove the old pixmap from the project. */ old_filename = gtk_object_get_data (GTK_OBJECT (widget), icon_p); glade_project_remove_pixmap (data->project, old_filename); gtk_object_set_data_full (GTK_OBJECT (widget), icon_p, g_strdup (filename), filename ? g_free : NULL); glade_project_add_pixmap (data->project, filename); if (filename) { GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file (filename, NULL); gtk_window_set_icon (GTK_WINDOW (widget), pixbuf); if (pixbuf) gdk_pixbuf_unref (pixbuf); } } if (data->action == GB_LOADING) g_free (filename); } }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_bonobo_dock_item_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gboolean locked, exclusive, never_floating, never_vertical, never_horizontal; gchar *shadow, *orientation; BonoboDockItemBehavior behavior; gint i; /* This is a bit of a hack, as some of the properties are now saved as packing properties instead of normal properties. */ if (data->action == GB_LOADING) { gchar *behavior_string; data->loading_type = GB_CHILD_PROPERTIES; behavior_string = load_string (data, Behavior); behavior = glade_util_flags_from_string (BONOBO_TYPE_DOCK_ITEM_BEHAVIOR, behavior_string); data->loading_type = GB_STANDARD_PROPERTIES; } else { behavior = BONOBO_DOCK_ITEM (widget)->behavior; locked = gb_widget_input_bool (data, Locked); if (data->apply) { if (locked) behavior |= BONOBO_DOCK_ITEM_BEH_LOCKED; else behavior &= ~BONOBO_DOCK_ITEM_BEH_LOCKED; /* This avoids any problems with redrawing the selection. */ if (data->action == GB_APPLYING) editor_clear_selection (NULL); gtk_widget_queue_resize (widget); } exclusive = gb_widget_input_bool (data, Exclusive); if (data->apply) { if (exclusive) behavior |= BONOBO_DOCK_ITEM_BEH_EXCLUSIVE; else behavior &= ~BONOBO_DOCK_ITEM_BEH_EXCLUSIVE; } never_floating = gb_widget_input_bool (data, NeverFloating); if (data->apply) { if (never_floating) behavior |= BONOBO_DOCK_ITEM_BEH_NEVER_FLOATING; else behavior &= ~BONOBO_DOCK_ITEM_BEH_NEVER_FLOATING; } never_vertical = gb_widget_input_bool (data, NeverVertical); if (data->apply) { if (never_vertical) behavior |= BONOBO_DOCK_ITEM_BEH_NEVER_VERTICAL; else behavior &= ~BONOBO_DOCK_ITEM_BEH_NEVER_VERTICAL; } never_horizontal = gb_widget_input_bool (data, NeverHorizontal); if (data->apply) { if (never_horizontal) behavior |= BONOBO_DOCK_ITEM_BEH_NEVER_HORIZONTAL; else behavior &= ~BONOBO_DOCK_ITEM_BEH_NEVER_HORIZONTAL; } } /* BonoboDockItem has no method for setting the behavior. */ BONOBO_DOCK_ITEM (widget)->behavior = behavior; shadow = gb_widget_input_choice (data, ShadowType); if (data->apply) { for (i = 0; i < sizeof (GbShadowValues) / sizeof (GbShadowValues[0]); i++) { if (!strcmp (shadow, GbShadowChoices[i]) || !strcmp (shadow, GbShadowSymbols[i])) { bonobo_dock_item_set_shadow_type (BONOBO_DOCK_ITEM (widget), GbShadowValues[i]); break; } } } orientation = gb_widget_input_choice (data, Orientation); if (data->apply) { for (i = 0; i < GladeOrientationSize; i++) { if (!strcmp (orientation, GladeOrientationChoices[i]) || !strcmp (orientation, GladeOrientationSymbols[i])) { bonobo_dock_item_set_orientation (BONOBO_DOCK_ITEM (widget), GladeOrientationValues[i]); /* This avoids any problems with redrawing the selection. */ if (data->action == GB_APPLYING) editor_clear_selection (NULL); /* FIXME: A test to see if changing orientation works. */ if (BONOBO_DOCK_ITEM (widget)->bin.child) gtk_widget_queue_resize (BONOBO_DOCK_ITEM (widget)->bin.child); break; } } } }