static void
gtk_check_button_update_node_state (GtkWidget *widget)
{
GtkCheckButtonPrivate *priv = gtk_check_button_get_instance_private (GTK_CHECK_BUTTON (widget));
GtkCssImageBuiltinType image_type;
GtkStateFlags state;
if (!priv->indicator_widget)
return;
state = gtk_widget_get_state_flags (widget);
/* XXX: This is somewhat awkward here, but there's no better
* way to update the icon
*/
if (state & GTK_STATE_FLAG_CHECKED)
image_type = GTK_IS_RADIO_BUTTON (widget) ? GTK_CSS_IMAGE_BUILTIN_OPTION : GTK_CSS_IMAGE_BUILTIN_CHECK;
else if (state & GTK_STATE_FLAG_INCONSISTENT)
image_type = GTK_IS_RADIO_BUTTON (widget) ? GTK_CSS_IMAGE_BUILTIN_OPTION_INCONSISTENT : GTK_CSS_IMAGE_BUILTIN_CHECK_INCONSISTENT;
else
image_type = GTK_CSS_IMAGE_BUILTIN_NONE;
gtk_icon_set_image (GTK_ICON (priv->indicator_widget), image_type);
gtk_widget_set_state_flags (priv->indicator_widget, state, TRUE);
}
static void
get_radio_button_groups (GtkWidget * widget, GList ** groups)
{
if (GTK_IS_RADIO_BUTTON (widget))
{
gchar *group = gtk_object_get_data (GTK_OBJECT (widget), Group);
gboolean found = FALSE;
if (group)
{
/* Check if group is already in list. */
GList *item = *groups;
while (item)
{
if (!strcmp ((gchar *) item->data, group))
{
found = TRUE;
break;
}
item = g_list_next (item);
}
if (!found)
*groups = g_list_insert_sorted (*groups, group, g_str_equal);
}
}
if (GTK_IS_CONTAINER (widget))
gtk_container_foreach (GTK_CONTAINER (widget),
(GtkCallback) get_radio_button_groups, groups);
}
static void
preferences_widget_sync_string (const gchar *key, GtkWidget *widget)
{
gchar *value;
if (empathy_conf_get_string (empathy_conf_get (), key, &value) && value) {
if (GTK_IS_ENTRY (widget)) {
gtk_entry_set_text (GTK_ENTRY (widget), value);
} else if (GTK_IS_RADIO_BUTTON (widget)) {
if (strcmp (key, EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM) == 0) {
GType type;
GEnumClass *enum_class;
GEnumValue *enum_value;
GSList *list;
GtkWidget *toggle_widget;
/* Get index from new string */
type = empathy_contact_list_store_sort_get_type ();
enum_class = G_ENUM_CLASS (g_type_class_peek (type));
enum_value = g_enum_get_value_by_nick (enum_class, value);
if (enum_value) {
list = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));
toggle_widget = g_slist_nth_data (list, enum_value->value);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_widget), TRUE);
}
} else {
g_warning ("Unhandled key:'%s' just had string change", key);
}
}
g_free (value);
}
}
static void
kolab_folder_metadata_ui_foldertype_cb (GtkRadioButton *btn,
gpointer userdata)
{
KolabFolderMetaUIData *uidata = NULL;
KolabFolderTypeID foldertype = KOLAB_FOLDER_TYPE_INVAL;
GtkWidget *ok_btn = NULL;
gpointer type = NULL;
g_return_if_fail (GTK_IS_RADIO_BUTTON (btn));
g_return_if_fail (userdata != NULL);
uidata = (KolabFolderMetaUIData *) userdata;
g_return_if_fail (uidata->widgets != NULL);
type = g_hash_table_lookup (uidata->widgets->folder_type_map,
(gpointer) btn);
if (type != NULL)
foldertype = GPOINTER_TO_UINT (type);
if ((foldertype > KOLAB_FOLDER_TYPE_INVAL) &&
(foldertype < KOLAB_FOLDER_LAST_TYPE)) {
uidata->metadata->foldertype = foldertype;
uidata->changed_metadata = TRUE;
}
ok_btn = e_kolab_plugin_util_ui_dialog_ref_button (uidata->dialog,
GTK_STOCK_OK,
TRUE);
g_return_if_fail (GTK_IS_BUTTON (ok_btn));
gtk_widget_set_sensitive (ok_btn, TRUE);
g_object_unref (ok_btn);
}
static void
update (void)
{
GString *s;
char *font_desc;
char *font_settings;
const char *text;
gboolean has_feature;
int i;
text = gtk_entry_get_text (GTK_ENTRY (entry));
font_desc = gtk_font_chooser_get_font (GTK_FONT_CHOOSER (font));
s = g_string_new ("");
has_feature = FALSE;
for (i = 0; i < 24; i++)
{
if (!gtk_widget_is_sensitive (toggle[i]))
continue;
if (GTK_IS_RADIO_BUTTON (toggle[i]))
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle[i])))
{
if (has_feature)
g_string_append (s, ", ");
g_string_append (s, gtk_buildable_get_name (GTK_BUILDABLE (toggle[i])));
g_string_append (s, " 1");
has_feature = TRUE;
}
}
else
{
if (has_feature)
g_string_append (s, ", ");
g_string_append (s, gtk_buildable_get_name (GTK_BUILDABLE (toggle[i])));
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle[i])))
g_string_append (s, " 1");
else
g_string_append (s, " 0");
has_feature = TRUE;
}
}
font_settings = g_string_free (s, FALSE);
gtk_label_set_text (GTK_LABEL (settings), font_settings);
s = g_string_new ("");
g_string_append_printf (s, "<span font_desc='%s' font_features='%s'>%s</span>", font_desc, font_settings, text);
gtk_label_set_markup (GTK_LABEL (label), s->str);
g_string_free (s, TRUE);
g_free (font_desc);
g_free (font_settings);
}
/**
* gimp_int_radio_group_set_active:
* @radio_button: Pointer to a #GtkRadioButton.
* @item_data: The @item_data of the radio button you want to select.
*
* Calls gtk_toggle_button_set_active() with the radio button that was created
* with a matching @item_data. This function does the same thing as
* gimp_radio_group_set_active(), but takes integers as @item_data instead
* of pointers.
**/
void
gimp_int_radio_group_set_active (GtkRadioButton *radio_button,
gint item_data)
{
g_return_if_fail (GTK_IS_RADIO_BUTTON (radio_button));
gimp_radio_group_set_active (radio_button, GINT_TO_POINTER (item_data));
}
/**
* gwy_radio_button_set_value:
* @button: A radio button to set associated value of.
* @value: Value to associate.
*
* Sets the integer value associated with a radio button.
*
* This function allow to change associated radio button values after creation
* or even construct a radio button group with associated integers without the
* help of gwy_radio_buttons_create().
**/
void
gwy_radio_button_set_value(GtkWidget *button,
gint value)
{
g_return_if_fail(GTK_IS_RADIO_BUTTON(button));
setup_quark();
g_object_set_qdata(G_OBJECT(button), gwyrb_quark, GINT_TO_POINTER(value));
}
/*******************************************************
* csv_export_show_range_cb
*
* call back for show range button
*******************************************************/
void
csv_export_show_range_cb (GtkRadioButton *button, gpointer user_data)
{
CsvExportInfo *info = user_data;
gboolean active;
g_return_if_fail (GTK_IS_RADIO_BUTTON(button));
active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(button));
gtk_widget_set_sensitive (info->csvd.table, active);
}
/**
* gwy_radio_buttons_get_current:
* @group: A radio button group created by gwy_radio_buttons_create().
*
* Gets the integer enum value corresponding to currently selected item.
*
* Returns: The enum value corresponding to currently selected item. In
* case of failure -1 is returned.
**/
gint
gwy_radio_buttons_get_current(GSList *group)
{
while (group) {
g_return_val_if_fail(GTK_IS_RADIO_BUTTON(group->data), -1);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(group->data)))
return GPOINTER_TO_INT(g_object_get_qdata(G_OBJECT(group->data),
gwyrb_quark));
group = g_slist_next(group);
}
return -1;
}
static void
send_response (AccessDialogHandle *handle)
{
GVariantBuilder opt_builder;
g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);
if (handle->request->exported)
request_unexport (handle->request);
if (handle->response == 0 && handle->choices != NULL)
{
GVariantBuilder choice_builder;
GHashTableIter iter;
const char *key;
GtkWidget *widget;
g_variant_builder_init (&choice_builder, G_VARIANT_TYPE_VARDICT);
g_hash_table_iter_init (&iter, handle->choices);
while (g_hash_table_iter_next (&iter, (gpointer *)&key, (gpointer *)&widget))
{
if (GTK_IS_RADIO_BUTTON (widget))
{
gchar **str;
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
continue;
str = g_strsplit (key, ":", -1);
g_variant_builder_add (&choice_builder, "{sv}", str[0], g_variant_new_string (str[1]));
g_strfreev (str);
}
else if (GTK_IS_CHECK_BUTTON (widget))
{
gboolean active;
active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
g_variant_builder_add (&choice_builder, "{sv}", key, g_variant_new_string (active ? "true" : "false"));
}
}
g_variant_builder_add (&opt_builder, "{sv}", "choices", g_variant_builder_end (&choice_builder));
}
xdp_impl_access_complete_access_dialog (handle->impl,
handle->invocation,
handle->response,
g_variant_builder_end (&opt_builder));
access_dialog_handle_close (handle);
}
/** Connect a GtkRadioButton widget to its stored value in the preferences database.
*
* @internal
*
* @param button A pointer to the radio button that should be
* connected.
*/
static void
gnc_prefs_connect_radio_button (GtkRadioButton *button)
{
gchar *group, *pref;
g_return_if_fail(GTK_IS_RADIO_BUTTON(button));
gnc_prefs_split_widget_name (gtk_buildable_get_name(GTK_BUILDABLE(button)), &group, &pref);
gnc_prefs_bind (group, pref, G_OBJECT (button), "active");
g_free (group);
g_free (pref);
}
/**
* gwy_radio_buttons_find:
* @group: A radio button group created by gwy_radio_buttons_create().
* @value: The value associated with the button to find.
*
* Finds a radio button by its associated integer value.
*
* Returns: The radio button corresponding to @value, or %NULL on failure.
**/
GtkWidget*
gwy_radio_buttons_find(GSList *group,
gint value)
{
g_return_val_if_fail(group, NULL);
while (group) {
g_return_val_if_fail(GTK_IS_RADIO_BUTTON(group->data), FALSE);
if (GPOINTER_TO_INT(g_object_get_qdata(G_OBJECT(group->data),
gwyrb_quark)) == value)
return GTK_WIDGET(group->data);
group = g_slist_next(group);
}
return NULL;
}
static void
reset (void)
{
int i;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (numcasedefault), TRUE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (numspacedefault), TRUE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fractiondefault), TRUE);
for (i = 0; i < 24; i++)
{
if (!GTK_IS_RADIO_BUTTON (toggle[i]))
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle[i]), FALSE);
gtk_widget_set_sensitive (toggle[i], FALSE);
}
}
}
static void
find_parents_group (GtkWidget * widget, GSList ** group)
{
/* If a group has already been found, return. */
if (*group)
return;
if (GTK_IS_RADIO_BUTTON (widget))
{
gchar *group_name = gtk_object_get_data (GTK_OBJECT (widget), Group);
/* Check if this radio button is using the default (parent's) group. */
if (group_name == NULL)
{
*group = gtk_radio_button_group (GTK_RADIO_BUTTON (widget));
}
}
}
static void
draw_option (GtkStyle *style,
GdkWindow *window,
GtkStateType state,
GtkShadowType shadow,
GdkRectangle *area,
GtkWidget *widget,
const gchar *detail,
gint x,
gint y,
gint width,
gint height)
{
ThemeMatchData match_data;
g_return_if_fail (style != NULL);
g_return_if_fail (window != NULL);
/* FIXME: memory leak */
LOG ("widget=%s, primitive=option, state=%s, shadow=%s, detail='%s', name='%s'",
G_OBJECT_TYPE_NAME (widget),
enum_value_to_string (gtk_state_type_get_type (), state),
enum_value_to_string (gtk_shadow_type_get_type (), shadow),
detail,
gtk_widget_get_name (widget));
match_data.function = TOKEN_D_OPTION;
match_data.detail = (gchar *)detail;
match_data.flags = THEME_MATCH_SHADOW | THEME_MATCH_STATE;
match_data.shadow = shadow;
match_data.state = state;
/* Special casing for GtkRadioButton: We want to set the widget state to
* ACTIVE to get the correct graphics used in the RC files. Ideally we'd
* use the FOCUS rules, but this is not possible due to technical limitations
* in how focus is drawn in sapwood */
if (GTK_IS_RADIO_BUTTON (widget) &&
gtk_widget_has_focus (widget))
match_data.state = GTK_STATE_ACTIVE;
if (!draw_simple_image (style, window, area, widget, &match_data, TRUE,
x, y, width, height))
GTK_STYLE_CLASS (sapwood_style_parent_class)->draw_option (
style, window, state, shadow, area, widget, detail, x, y, width, height);
}
/**
* gwy_radio_buttons_get_current:
* @group: A radio button group created by gwy_radio_buttons_create().
* @key: Value object data key (specified as @key when called
* gwy_radio_buttons_create()).
*
* Gets the integer enum value corresponding to currently selected item.
*
* Returns: The enum value corresponding to currently selected item. In
* case of failure -1 is returned.
*
* Since: 1.2.
**/
gint
gwy_radio_buttons_get_current(GSList *group,
const gchar *key)
{
GQuark quark;
quark = g_quark_from_string(key);
while (group) {
g_return_val_if_fail(GTK_IS_RADIO_BUTTON(group->data), -1);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(group->data)))
return GPOINTER_TO_INT(g_object_get_qdata(G_OBJECT(group->data),
quark));
group = g_slist_next(group);
}
return -1;
}
/** Connect a GtkRadioButton widget to its stored value in the preferences database.
*
* @internal
*
* @param button A pointer to the radio button that should be
* connected.
*/
static void
gnc_prefs_connect_radio_button (GtkRadioButton *button)
{
gchar *group, *pref;
gboolean active;
g_return_if_fail(GTK_IS_RADIO_BUTTON(button));
gnc_prefs_split_widget_name (gtk_buildable_get_name(GTK_BUILDABLE(button)), &group, &pref);
// active = gnc_prefs_get_bool (group, pref);
// DEBUG(" Checkbox %s/%s initially %sactive", group, pref, active ? "" : "in");
// gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
gnc_prefs_bind (group, pref, G_OBJECT (button), "active");
g_free(group);
g_free(pref);
}
/*******************************************************
* csv_export_end_date_cb
*
* call back for when the end date changes
*******************************************************/
void
csv_export_end_date_cb (GtkWidget *radio, gpointer user_data)
{
CsvExportInfo *info = user_data;
const gchar *name;
gboolean active;
g_return_if_fail (GTK_IS_RADIO_BUTTON(radio));
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(radio)))
{
LEAVE("1st callback of pair. Defer to 2nd callback.");
return;
}
name = gtk_buildable_get_name (GTK_BUILDABLE(radio));
active = (g_strcmp0 (name, "end_date_choose") == 0 ? 1 : 0 );
gtk_widget_set_sensitive (info->csvd.end_date, active);
get_filter_times (info);
}
/**
* gwy_radio_buttons_set_current:
* @group: A radio button group created by gwy_radio_buttons_create().
* @key: Value object data key (specified as @key when called
* gwy_radio_buttons_create()).
* @current: Value to be shown as currently selected.
*
* Sets currently selected radio button in @group based on integer item object
* data (as set by gwy_radio_buttons_create()).
*
* Returns: %TRUE if current button was set, %FALSE if @current was not found.
*
* Since: 1.2.
**/
gboolean
gwy_radio_buttons_set_current(GSList *group,
const gchar *key,
gint current)
{
GQuark quark;
g_return_val_if_fail(group, FALSE);
quark = g_quark_from_string(key);
while (group) {
g_return_val_if_fail(GTK_IS_RADIO_BUTTON(group->data), FALSE);
if (GPOINTER_TO_INT(g_object_get_qdata(G_OBJECT(group->data), quark))
== current) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(group->data), TRUE);
return TRUE;
}
group = g_slist_next(group);
}
return FALSE;
}
/**
* gimp_radio_group_set_active:
* @radio_button: Pointer to a #GtkRadioButton.
* @item_data: The @item_data of the radio button you want to select.
*
* Calls gtk_toggle_button_set_active() with the radio button that was
* created with a matching @item_data.
**/
void
gimp_radio_group_set_active (GtkRadioButton *radio_button,
gpointer item_data)
{
GtkWidget *button;
GSList *group;
g_return_if_fail (GTK_IS_RADIO_BUTTON (radio_button));
for (group = gtk_radio_button_get_group (radio_button);
group;
group = g_slist_next (group))
{
button = GTK_WIDGET (group->data);
if (g_object_get_data (G_OBJECT (button), "gimp-item-data") == item_data)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
return;
}
}
}
/* This recursively steps though a complete component's hierarchy to find
a radio button with a particular group name set. When found the radio
button's group list is returned in find_group_data->group. */
static void
find_group (GtkWidget * widget, GbFindGroupData * find_group_data)
{
/* If group has been found just return. */
if (find_group_data->group)
return;
if (GTK_IS_RADIO_BUTTON (widget))
{
gchar *group_name = gtk_object_get_data (GTK_OBJECT (widget), Group);
if (group_name && !strcmp (group_name, find_group_data->group_name))
{
find_group_data->group
= gtk_radio_button_group (GTK_RADIO_BUTTON (widget));
return;
}
}
if (GTK_IS_CONTAINER (widget))
gtk_container_foreach (GTK_CONTAINER (widget),
(GtkCallback) find_group, find_group_data);
}
/** \brief Update the printer driver widget
*
* \param[in] widget printer driver widget
* \param[in] driver driver name
*/
void printer_driver_widget_update(GtkWidget *widget, const char *driver)
{
GtkWidget *radio;
int index = 4; /* RAW for 4/5 */
int device;
/* get device number from custom GObject property */
device = GPOINTER_TO_INT(
g_object_get_data(G_OBJECT(widget), "DeviceNumber"));
/* this is a little silly, using string constants, but it works */
if (device == 4 || device == 5) {
if (strcmp(driver, "ascii") == 0) {
index = 1;
} else if (strcmp(driver, "mps803") == 0) {
index = 2;
} else if (strcmp(driver, "nl10") == 0) {
index = 3;
}
} else if (device == 6) {
if (strcmp(driver, "1520") == 0) {
index = 1;
} else {
index = 2; /* RAW */
}
} else {
fprintf(stderr, "%s:%d:%s(): invalid printer device #%d\n",
__FILE__, __LINE__, __func__, device);
archdep_vice_exit(1);
}
/* now select the proper radio button */
radio = gtk_grid_get_child_at(GTK_GRID(widget), 0, index);
if (radio != NULL && GTK_IS_RADIO_BUTTON(radio)) {
/* set toggle button to active, this also sets the resource */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), TRUE);
}
}
static void paintToggle(RenderThemeGtk* theme, RenderObject* renderObject, const PaintInfo& info, const IntRect& rect, GtkWidget* widget)
{
// We do not call gtk_toggle_button_set_active here, because some themes begin a series of
// animation frames in a "toggled" signal handler. This puts some checkboxes in a half-way
// checked state. Every GTK+ theme I tested merely looks at the shadow type (and not the
// 'active' property) to determine whether or not to draw the check.
gtk_widget_set_sensitive(widget, theme->isEnabled(renderObject) && !theme->isReadOnlyControl(renderObject));
gtk_widget_set_direction(widget, gtkTextDirection(renderObject->style().direction()));
bool indeterminate = theme->isIndeterminate(renderObject);
gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(widget), indeterminate);
GtkShadowType shadowType = GTK_SHADOW_OUT;
if (indeterminate) // This originates from the Mozilla code.
shadowType = GTK_SHADOW_ETCHED_IN;
else if (theme->isChecked(renderObject))
shadowType = GTK_SHADOW_IN;
WidgetRenderingContext widgetContext(info.context, rect);
IntRect buttonRect(IntPoint(), rect.size());
GtkStateType toggleState = getGtkStateType(theme, renderObject);
const char* detail = 0;
if (GTK_IS_RADIO_BUTTON(widget)) {
detail = "radiobutton";
widgetContext.gtkPaintOption(buttonRect, widget, toggleState, shadowType, detail);
} else {
detail = "checkbutton";
widgetContext.gtkPaintCheck(buttonRect, widget, toggleState, shadowType, detail);
}
if (theme->isFocused(renderObject)) {
IntRect focusRect(buttonRect);
adjustRectForFocus(widget, focusRect, true);
widgetContext.gtkPaintFocus(focusRect, widget, toggleState, detail);
}
}
void
gimp_enum_radio_box_add (GtkBox *box,
GtkWidget *widget,
gint enum_value,
gboolean below)
{
GList *children;
GList *list;
gint pos;
g_return_if_fail (GTK_IS_BOX (box));
g_return_if_fail (GTK_IS_WIDGET (widget));
children = gtk_container_get_children (GTK_CONTAINER (box));
for (list = children, pos = 1;
list;
list = g_list_next (list), pos++)
{
if (GTK_IS_RADIO_BUTTON (list->data) &&
GPOINTER_TO_INT (g_object_get_data (list->data, "gimp-item-data")) ==
enum_value)
{
GtkWidget *radio = list->data;
GtkWidget *hbox;
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), hbox, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (box), hbox, pos);
if (below)
{
GtkWidget *spacer;
gint indicator_size;
gint indicator_spacing;
gint focus_width;
gint focus_padding;
gint border_width;
gtk_widget_style_get (radio,
"indicator-size", &indicator_size,
"indicator-spacing", &indicator_spacing,
"focus-line-width", &focus_width,
"focus-padding", &focus_padding,
NULL);
border_width = gtk_container_get_border_width (GTK_CONTAINER (radio));
spacer = gtk_vbox_new (FALSE, 0);
gtk_widget_set_size_request (spacer,
indicator_size +
3 * indicator_spacing +
focus_width +
focus_padding +
border_width,
-1);
gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0);
gtk_widget_show (spacer);
}
else
{
GtkSizeGroup *size_group;
size_group = g_object_get_data (G_OBJECT (box), "size-group");
if (! size_group)
{
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
g_object_set_data (G_OBJECT (box), "size-group", size_group);
gtk_size_group_add_widget (size_group, radio);
g_object_unref (size_group);
}
else
{
gtk_size_group_add_widget (size_group, radio);
}
gtk_box_set_spacing (GTK_BOX (hbox), 4);
g_object_ref (radio);
gtk_container_remove (GTK_CONTAINER (box), radio);
gtk_box_pack_start (GTK_BOX (hbox), radio, FALSE, FALSE, 0);
g_object_unref (radio);
}
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
g_object_bind_property (radio, "active",
widget, "sensitive",
G_BINDING_SYNC_CREATE);
gtk_widget_show (hbox);
break;
}
}
g_list_free (children);
}
void
gimp_enum_radio_frame_add (GtkFrame *frame,
GtkWidget *widget,
gint enum_value)
{
GtkWidget *vbox;
GList *children;
GList *list;
gint pos;
g_return_if_fail (GTK_IS_FRAME (frame));
g_return_if_fail (GTK_IS_WIDGET (widget));
vbox = gtk_bin_get_child (GTK_BIN (frame));
g_return_if_fail (GTK_IS_VBOX (vbox));
children = gtk_container_get_children (GTK_CONTAINER (vbox));
for (list = children, pos = 1;
list;
list = g_list_next (list), pos++)
{
if (GTK_IS_RADIO_BUTTON (list->data) &&
GPOINTER_TO_INT (g_object_get_data (list->data, "gimp-item-data")) ==
enum_value)
{
GtkWidget *radio = list->data;
GtkWidget *hbox;
GtkWidget *spacer;
gint indicator_size;
gint indicator_spacing;
gint focus_width;
gint focus_padding;
gtk_widget_style_get (radio,
"indicator-size", &indicator_size,
"indicator-spacing", &indicator_spacing,
"focus-line-width", &focus_width,
"focus-padding", &focus_padding,
NULL);
hbox = gtk_hbox_new (FALSE, 0);
spacer = gtk_vbox_new (FALSE, 0);
gtk_widget_set_size_request (spacer,
indicator_size +
3 * indicator_spacing +
focus_width +
focus_padding +
GTK_CONTAINER (radio)->border_width,
-1);
gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0);
gtk_widget_show (spacer);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
g_object_set_data (G_OBJECT (radio), "set_sensitive", hbox);
g_signal_connect (radio, "toggled",
G_CALLBACK (gimp_toggle_button_sensitive_update),
NULL);
gtk_widget_set_sensitive (hbox,
GTK_TOGGLE_BUTTON (list->data)->active);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (vbox), hbox, pos);
gtk_widget_show (hbox);
break;
}
}
g_list_free (children);
}
/**
* gwy_radio_button_get_value:
* @button: A radio button belonging to a group created by
* gwy_radio_buttons_create().
*
* Gets the integer value associated with a radio button.
*
* Returns: The integer value corresponding to @button.
**/
gint
gwy_radio_button_get_value(GtkWidget *button)
{
g_return_val_if_fail(GTK_IS_RADIO_BUTTON(button), -1);
return GPOINTER_TO_INT(g_object_get_qdata(G_OBJECT(button), gwyrb_quark));
}
/** Connect one dialog widget to the appropriate callback function for
* its type.
*
* @internal
*
* @param name The name of the widget.
*
* @param widget A pointer to the widget.
*
* @param dialog A pointer to the dialog.
*/
static void
gnc_prefs_connect_one (const gchar *name,
GtkWidget *widget,
gpointer user_data)
{
/* These tests must be ordered from more specific widget to less
* specific widget. */
if (GTK_IS_FONT_BUTTON(widget))
{
DEBUG(" %s - entry", name);
gnc_prefs_connect_font_button(GTK_FONT_BUTTON(widget));
}
else if (GTK_IS_RADIO_BUTTON(widget))
{
DEBUG(" %s - radio button", name);
gnc_prefs_connect_radio_button(GTK_RADIO_BUTTON(widget));
}
else if (GTK_IS_CHECK_BUTTON(widget))
{
DEBUG(" %s - check button", name);
gnc_prefs_connect_check_button(GTK_CHECK_BUTTON(widget));
}
else if (GTK_IS_SPIN_BUTTON(widget))
{
DEBUG(" %s - spin button", name);
gnc_prefs_connect_spin_button(GTK_SPIN_BUTTON(widget));
}
else if (GTK_IS_COMBO_BOX(widget))
{
DEBUG(" %s - combo box", name);
gnc_prefs_connect_combo_box(GTK_COMBO_BOX(widget));
}
else if (GTK_IS_ENTRY(widget))
{
DEBUG(" %s - entry", name);
gnc_prefs_connect_entry(GTK_ENTRY(widget));
}
else if (GTK_IS_HBOX(widget))
{
/* Test custom widgets are all children of a hbox */
GtkWidget *widget_child;
GList* child = gtk_container_get_children(GTK_CONTAINER(widget));
widget_child = child->data;
g_list_free(child);
DEBUG(" %s - hbox", name);
DEBUG("Hbox widget type is %s and name is %s", gtk_widget_get_name(GTK_WIDGET(widget_child)), name);
if (GNC_IS_CURRENCY_EDIT(widget_child))
{
DEBUG(" %s - currency_edit", name);
gnc_prefs_connect_currency_edit(GNC_CURRENCY_EDIT(widget_child), name );
}
else if (GNC_IS_PERIOD_SELECT(widget_child))
{
DEBUG(" %s - period_Select", name);
gnc_prefs_connect_period_select(GNC_PERIOD_SELECT(widget_child), name );
}
else if (GNC_IS_DATE_EDIT(widget_child))
{
DEBUG(" %s - date_edit", name);
gnc_prefs_connect_date_edit(GNC_DATE_EDIT(widget_child), name );
}
}
else
{
DEBUG(" %s - unsupported %s", name,
G_OBJECT_TYPE_NAME(G_OBJECT(widget)));
}
}
