void
properties_cb (GtkAction *action, SeahorseApplet *sapplet)
{
SeahorseWidget *swidget;
GtkWidget *widget;
GdkPixbuf *pixbuf;
swidget = seahorse_widget_new ("applet-preferences", NULL);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, swidget->name));
pixbuf = gtk_widget_render_icon (widget,
ICON_CLIPBOARD_DEFAULT,
(GtkIconSize)-1,
NULL);
gtk_window_set_icon (GTK_WINDOW (widget), pixbuf);
g_object_unref(pixbuf);
/* Preferences window is already open */
if (!swidget)
return;
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "show-clipboard-state"));
if (widget && GTK_IS_CHECK_BUTTON (widget))
seahorse_check_button_gconf_attach (GTK_CHECK_BUTTON (widget), SHOW_CLIPBOARD_STATE_KEY);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "display-encrypted-clipboard"));
if (widget && GTK_IS_CHECK_BUTTON (widget))
seahorse_check_button_gconf_attach (GTK_CHECK_BUTTON (widget), DISPLAY_CLIPBOARD_ENC_KEY);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "display-decrypted-clipboard"));
if (widget && GTK_IS_CHECK_BUTTON (widget))
seahorse_check_button_gconf_attach (GTK_CHECK_BUTTON (widget), DISPLAY_CLIPBOARD_DEC_KEY);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "display-verified-clipboard"));
if (widget && GTK_IS_CHECK_BUTTON (widget))
seahorse_check_button_gconf_attach (GTK_CHECK_BUTTON (widget), DISPLAY_CLIPBOARD_VER_KEY);
widget = GTK_WIDGET (seahorse_widget_get_widget (swidget, "close"));
g_signal_connect (widget, "clicked", G_CALLBACK (close_props), swidget);
widget = seahorse_widget_get_toplevel (swidget);
g_signal_connect (widget, "delete-event", G_CALLBACK (win_destroyed), swidget);
seahorse_widget_show (swidget);
}
void
test_wheel_axes (gconstpointer data)
{
GtkWidget *button;
gint widget_value;
const gchar *widget_name;
WheelAxisAssertFunction assert_function;
widget_name = gcut_data_get_string(data, "widget-name");
assert_function = gcut_data_get_pointer(data, "assert-function");
enable_widget("wheel_emulation_box");
button = get_widget(widget_name);
cut_assert_true(GTK_IS_CHECK_BUTTON(button));
cut_assert_equal_int(4, get_scroll_axes_property_of_xinput());
widget_value = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
assert_function(widget_value);
gtk_test_widget_click(button, 1, 0);
wait_action();
cut_assert_equal_int(4, get_scroll_axes_property_of_xinput());
widget_value = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
assert_function(widget_value);
}
static void make_widget_update_signal_based(struct iio_widget *widgets,
unsigned int num_widgets)
{
char signal_name[25];
unsigned int i;
for (i = 0; i < num_widgets; i++) {
if (GTK_IS_CHECK_BUTTON(widgets[i].widget))
sprintf(signal_name, "%s", "toggled");
else if (GTK_IS_TOGGLE_BUTTON(widgets[i].widget))
sprintf(signal_name, "%s", "toggled");
else if (GTK_IS_SPIN_BUTTON(widgets[i].widget))
sprintf(signal_name, "%s", "value-changed");
else if (GTK_IS_COMBO_BOX_TEXT(widgets[i].widget))
sprintf(signal_name, "%s", "changed");
else
printf("unhandled widget type, attribute: %s\n", widgets[i].attr_name);
if (GTK_IS_SPIN_BUTTON(widgets[i].widget) &&
widgets[i].priv_progress != NULL) {
iio_spin_button_progress_activate(&widgets[i]);
} else {
g_signal_connect(G_OBJECT(widgets[i].widget), signal_name, G_CALLBACK(save_widget_value), &widgets[i]);
}
}
}
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 GtkCheckButton widget to its stored value in the preferences database.
*
* @internal
*
* @param button A pointer to the check button that should be
* connected.
*/
static void
gnc_prefs_connect_check_button (GtkCheckButton *button)
{
gchar *group, *pref;
g_return_if_fail(GTK_IS_CHECK_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);
}
static void
save_active_property_value_to_config (GtkWidget *widget, gpointer data) {
GValue value = G_VALUE_INIT;
if (GTK_IS_COMBO_BOX (widget)) {
g_value_init (&value, G_TYPE_INT);
} else if (GTK_IS_CHECK_BUTTON (widget)) {
g_value_init (&value, G_TYPE_BOOLEAN);
} else {
trace ("FATAL: %s unsupported widget type\n", __FUNCTION__);
}
g_object_get_property (G_OBJECT (widget), "active", &value);
vk_set_config_var ((const gchar *) data, &value);
}
static void
gail_toggle_button_real_initialize (AtkObject *obj,
gpointer data)
{
ATK_OBJECT_CLASS (gail_toggle_button_parent_class)->initialize (obj, data);
g_signal_connect (data,
"toggled",
G_CALLBACK (gail_toggle_button_toggled_gtk),
NULL);
if (GTK_IS_CHECK_BUTTON (data))
obj->role = ATK_ROLE_CHECK_BOX;
else
obj->role = ATK_ROLE_TOGGLE_BUTTON;
}
/* hooks up the signals for check and radio buttons */
void
aurora_animation_connect_checkbox (GtkWidget *widget)
{
if (GTK_IS_CHECK_BUTTON (widget))
{
if (!g_slist_find_custom (connected_widgets, widget, find_signal_info))
{
SignalInfo * signal_info = g_new (SignalInfo, 1);
signal_info->widget = widget;
signal_info->handler_id = g_signal_connect ((GObject*)widget, "toggled", G_CALLBACK (on_checkbox_toggle), NULL);
connected_widgets = g_slist_append (connected_widgets, signal_info);
g_object_weak_ref (G_OBJECT (widget), on_connected_widget_destruction, signal_info);
}
}
}
static void netplay_update_control_res(GtkWidget *w, gpointer data)
{
unsigned int control, mask;
g_return_if_fail(GTK_IS_CHECK_BUTTON(w));
g_return_if_fail(data != 0);
mask = *((unsigned int *)data);
resources_get_int("NetworkControl", (int *)&control);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))) {
control |= mask;
} else {
control &= ~mask;
}
resources_set_int("NetworkControl", (int)control);
}
static void
draw_check (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=check, 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_CHECK;
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 GtkCheckButton: 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_CHECK_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_check (
style, window, state, shadow, area, widget, detail, x, y, width, height);
}
/** Connect a GtkCheckButton widget to its stored value in the preferences database.
*
* @internal
*
* @param button A pointer to the check button that should be
* connected.
*/
static void
gnc_prefs_connect_check_button (GtkCheckButton *button)
{
gchar *group, *pref;
gboolean active;
g_return_if_fail(GTK_IS_CHECK_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);
}
static void InsertWidgetInTable(GtkWidget* table, GtkWidget *left, GtkWidget *right = NULL, GtkWidget *third = NULL) {
GtkAttachOptions opt = (GtkAttachOptions)(GTK_EXPAND | GTK_FILL); // default
guint l_xpad = GTK_IS_CHECK_BUTTON(left) ? 0 : 22;
guint r_xpad = 0;
guint ypad = 0;
if (!left) {
gtk_table_attach(GTK_TABLE(table), right, 1, 2, s_table_line, s_table_line+1, opt, opt, r_xpad, ypad);
} else if (!right) {
gtk_table_attach(GTK_TABLE(table), left, 0, 1, s_table_line, s_table_line+1, opt, opt, l_xpad, ypad);
} else if (right == left) {
gtk_table_attach(GTK_TABLE(table), left, 0, 2, s_table_line, s_table_line+1, opt, opt, r_xpad, ypad);
} else {
gtk_table_attach(GTK_TABLE(table), left, 0, 1, s_table_line, s_table_line+1, opt, opt, l_xpad, ypad);
gtk_table_attach(GTK_TABLE(table), right, 1, 2, s_table_line, s_table_line+1, opt, opt, r_xpad, ypad);
}
if (third) {
gtk_table_attach(GTK_TABLE(table), third, 2, 3, s_table_line, s_table_line+1, opt, opt, r_xpad, ypad);
}
s_table_line++;
}
void InsertWidgetInTable(GtkWidget* table, GtkWidget *left, GtkWidget *right = NULL, GtkWidget *third = NULL)
{
guint l_xpad = GTK_IS_CHECK_BUTTON(left) ? 0 : 22;
if (!left) {
AttachInTable(table, right, 1);
} else if (!right) {
AttachInTable(table, left, 0, l_xpad);
} else if (right == left) {
AttachInTable(table, right, 0, 0, 2);
} else {
AttachInTable(table, left, 0, l_xpad);
AttachInTable(table, right, 1);
}
if (third) {
AttachInTable(table, third, 2);
}
s_table_line++;
}
static void gconf_dialog_onResetButtonPressed (GConfDialog* self, GtkButton* widget) {
GConfSchema* schema;
GConfValue* default_value;
GtkWidget* target;
g_return_if_fail (self != NULL);
g_return_if_fail (widget != NULL);
schema = (GConfSchema*) g_object_get_data ((GObject*) widget, "gconf-schema");
default_value = gconf_schema_get_default_value (schema);
target = _g_object_ref0 ((GtkWidget*) g_object_get_data ((GObject*) widget, "target"));
switch (gconf_schema_get_type (schema)) {
case GCONF_VALUE_BOOL:
{
GtkWidget* _tmp0_;
GtkCheckButton* checkbutton;
checkbutton = _g_object_ref0 ((_tmp0_ = target, GTK_IS_CHECK_BUTTON (_tmp0_) ? ((GtkCheckButton*) _tmp0_) : NULL));
gtk_toggle_button_set_active ((GtkToggleButton*) checkbutton, gconf_value_get_bool (default_value));
_g_object_unref0 (checkbutton);
break;
}
case GCONF_VALUE_STRING:
{
GtkWidget* _tmp1_;
GtkEntry* entrybox;
entrybox = _g_object_ref0 ((_tmp1_ = target, GTK_IS_ENTRY (_tmp1_) ? ((GtkEntry*) _tmp1_) : NULL));
gtk_entry_set_text (entrybox, gconf_value_get_string (default_value));
_g_object_unref0 (entrybox);
break;
}
case GCONF_VALUE_INT:
{
GtkWidget* _tmp2_;
GtkSpinButton* spin;
spin = _g_object_ref0 ((_tmp2_ = target, GTK_IS_SPIN_BUTTON (_tmp2_) ? ((GtkSpinButton*) _tmp2_) : NULL));
gtk_spin_button_set_value (spin, (double) gconf_value_get_int (default_value));
_g_object_unref0 (spin);
break;
}
}
_g_object_unref0 (target);
}
/**
* hildon_caption_new:
* @group: a #GtkSizeGroup for controlling the size of related captions or %NULL
* @value: the caption text to accompany the text entry. The widget makes
* a copy of this text.
* @control: the control that is to be captioned.
* @icon: an icon to accompany the label or %NULL in case no icon should be displayed.
* @flag: indicates whether this captioned control is mandatory or
* optional.
*
* Creates a new instance of #HildonCaption widget, with a specific
* control and image.
* Note: Clicking on a focused caption will trigger the activate signal.
* The default behaviour for the caption's activate signal is to call
* gtk_widget_activate() on its control.
*
* Returns: a new #HildonCaption
*/
GtkWidget*
hildon_caption_new (GtkSizeGroup *group,
const gchar *value,
GtkWidget *child,
GtkWidget *icon,
HildonCaptionStatus flag)
{
GtkWidget *widget;
g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
widget = g_object_new (HILDON_TYPE_CAPTION,
"label", value,
"child", child,
"size_group", group,
"icon", icon,
"status", flag,
NULL);
/* Do not expand GtkCheckButton by default, we want to reduce its activation area */
if (GTK_IS_CHECK_BUTTON (child))
hildon_caption_set_child_expand (HILDON_CAPTION (widget), FALSE);
return widget;
}
static void gmpc_tools_metadata_appearance_real_preferences_pane_construct (GmpcPluginPreferencesIface* base, GtkContainer* container) {
GmpcToolsMetadataAppearance * self;
GtkBuilder* _tmp0_ = NULL;
GtkBuilder* builder;
gchar* _tmp1_ = NULL;
gchar* preferences_ui_file;
GObject* _tmp2_ = NULL;
GObject* _tmp3_;
GtkWidget* _tmp4_;
GtkWidget* builderWidget;
GObject* _tmp5_ = NULL;
GObject* _tmp6_;
GtkWidget* _tmp7_;
gint _tmp8_;
GObject* _tmp9_ = NULL;
GObject* _tmp10_;
GtkWidget* _tmp11_;
gint _tmp12_;
GObject* _tmp13_ = NULL;
GObject* _tmp14_;
GtkWidget* _tmp15_;
gint _tmp16_;
GObject* _tmp17_ = NULL;
GObject* _tmp18_;
GtkWidget* _tmp19_;
gint _tmp20_;
GObject* _tmp21_ = NULL;
GObject* _tmp22_;
GtkWidget* _tmp23_;
gint _tmp24_;
GObject* _tmp25_ = NULL;
GObject* _tmp26_;
GtkWidget* _tmp27_;
gint _tmp28_;
GError * _inner_error_ = NULL;
self = (GmpcToolsMetadataAppearance*) base;
g_return_if_fail (container != NULL);
_tmp0_ = gtk_builder_new ();
builder = _tmp0_;
_tmp1_ = gmpc_get_full_glade_path ("preferences-metadata-appearance.ui");
preferences_ui_file = _tmp1_;
gtk_builder_add_from_file (builder, preferences_ui_file, &_inner_error_);
if (_inner_error_ != NULL) {
_g_free0 (preferences_ui_file);
_g_object_unref0 (builder);
goto __catch15_g_error;
}
gtk_builder_connect_signals (builder, NULL);
_tmp2_ = gtk_builder_get_object (builder, "frame_metadata_appearance_settings");
_tmp3_ = _tmp2_;
_tmp4_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_FRAME (_tmp3_) ? ((GtkFrame*) _tmp3_) : NULL));
builderWidget = _tmp4_;
gtk_container_add (container, builderWidget);
gtk_widget_show_all (builderWidget);
_tmp5_ = gtk_builder_get_object (builder, "checkbutton_show_lyrics");
_tmp6_ = _tmp5_;
_tmp7_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp6_) ? ((GtkCheckButton*) _tmp6_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp7_;
_tmp8_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-lyrics", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp8_);
_tmp9_ = gtk_builder_get_object (builder, "checkbutton_show_artist_information");
_tmp10_ = _tmp9_;
_tmp11_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp10_) ? ((GtkCheckButton*) _tmp10_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp11_;
_tmp12_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-artist-information", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp12_);
_tmp13_ = gtk_builder_get_object (builder, "checkbutton_show_web_links");
_tmp14_ = _tmp13_;
_tmp15_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp14_) ? ((GtkCheckButton*) _tmp14_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp15_;
_tmp16_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-web-links", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp16_);
_tmp17_ = gtk_builder_get_object (builder, "checkbutton_show_similar_artists");
_tmp18_ = _tmp17_;
_tmp19_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp18_) ? ((GtkCheckButton*) _tmp18_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp19_;
_tmp20_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-similar-artist", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp20_);
_tmp21_ = gtk_builder_get_object (builder, "checkbutton_show_similar_songs");
_tmp22_ = _tmp21_;
_tmp23_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp22_) ? ((GtkCheckButton*) _tmp22_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp23_;
_tmp24_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-similar-songs", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp24_);
_tmp25_ = gtk_builder_get_object (builder, "checkbutton_show_guitar_tabs");
_tmp26_ = _tmp25_;
_tmp27_ = _g_object_ref0 ((GtkWidget*) (GTK_IS_CHECK_BUTTON (_tmp26_) ? ((GtkCheckButton*) _tmp26_) : NULL));
_g_object_unref0 (builderWidget);
builderWidget = _tmp27_;
_tmp28_ = cfg_get_single_value_as_int_with_default (config, "MetaData", "show-guitar-tabs", 1);
gtk_toggle_button_set_active ((GtkToggleButton*) GTK_CHECK_BUTTON (builderWidget), (gboolean) _tmp28_);
_g_object_unref0 (builderWidget);
_g_free0 (preferences_ui_file);
_g_object_unref0 (builder);
goto __finally15;
__catch15_g_error:
{
GError * e;
e = _inner_error_;
_inner_error_ = NULL;
fprintf (stderr, "Could not load UI: %s\n", e->message);
_g_error_free0 (e);
}
__finally15:
if (_inner_error_ != NULL) {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
/** 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)));
}
}
void
e_kolab_folder_metadata_ui_update_from_uidata (KolabFolderMetaUIData *uidata)
{
GtkWidget *widget = NULL;
gulong handler_id = 0;
guint ii = 0;
g_return_if_fail (uidata != NULL);
g_return_if_fail (E_IS_SHELL_VIEW (uidata->shell_view));
g_return_if_fail (E_IS_ALERT_BAR (uidata->alert_bar));
g_return_if_fail (uidata->metadata != NULL);
g_return_if_fail (uidata->widgets != NULL);
/* When updating the state of the UI here,
* we need to always make sure not to trigger
* signals which we may have handlers for.
* Updating the UI this way is meant to happen
* before the user actually uses it.
*/
/* radio button group (current folder type) */
for (ii = 0; ii < KOLAB_FOLDER_META_UI_NUM_TYPES; ii++) {
g_signal_handler_block (uidata->widgets->radio_btn_type[ii],
uidata->widgets->radio_btn_handler_id[ii]);
}
switch (uidata->metadata->foldertype) {
case KOLAB_FOLDER_TYPE_EVENT:
case KOLAB_FOLDER_TYPE_EVENT_DEFAULT:
ii = 1;
break;
case KOLAB_FOLDER_TYPE_NOTE:
case KOLAB_FOLDER_TYPE_NOTE_DEFAULT:
ii = 2;
break;
case KOLAB_FOLDER_TYPE_TASK:
case KOLAB_FOLDER_TYPE_TASK_DEFAULT:
ii = 3;
break;
case KOLAB_FOLDER_TYPE_CONTACT:
case KOLAB_FOLDER_TYPE_CONTACT_DEFAULT:
ii = 4;
break;
default:
/* all else is regarded email */
ii = 0;
}
widget = uidata->widgets->radio_btn_type[ii];
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
for (ii = 0; ii < KOLAB_FOLDER_META_UI_NUM_TYPES; ii++) {
g_signal_handler_unblock (uidata->widgets->radio_btn_type[ii],
uidata->widgets->radio_btn_handler_id[ii]);
}
/* PIM options */
/* option: sync conflict strategy */
widget = uidata->widgets->cbox_syncstrategy;
g_return_if_fail (GTK_IS_COMBO_BOX_TEXT (widget));
handler_id = uidata->widgets->cbox_syncstrategy_id;
g_signal_handler_block (widget, handler_id);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget),
(gint) uidata->metadata->strategy);
g_signal_handler_unblock (widget, handler_id);
/* whether to show all PIM folders in email view */
widget = uidata->widgets->chk_btn_show_all;
g_return_if_fail (GTK_IS_CHECK_BUTTON (widget));
handler_id = uidata->widgets->chk_btn_show_all_handler_id;
g_signal_handler_block (widget, handler_id);
if (uidata->metadata->show_all)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
FALSE);
g_signal_handler_unblock (widget, handler_id);
}
GtkWidget*
stpui_slider_new (stp_vars_t *vars,const char *optname,GtkWidget *checkbutton)
{
stp_parameter_t desc;
double step=1.0;
stpui_Slider *c=STPUI_SLIDER(g_object_new (stpui_slider_get_type (), NULL));
gboolean active=FALSE;
c->vars=vars;
c->optionname=optname;
c->checkbutton=NULL;
c->label=NULL;
if(GTK_IS_CHECK_BUTTON(checkbutton))
c->checkbutton=GTK_CHECK_BUTTON(checkbutton);
else
c->label=checkbutton;
stp_describe_parameter(c->vars,c->optionname,&desc);
c->type=desc.p_type;
switch(c->type)
{
case STP_PARAMETER_TYPE_DOUBLE:
active=stp_check_float_parameter(c->vars,c->optionname,STP_PARAMETER_DEFAULTED);
step=0.01;
break;
case STP_PARAMETER_TYPE_INT:
active=stp_check_int_parameter(c->vars,c->optionname,STP_PARAMETER_DEFAULTED);
step=1.0;
break;
case STP_PARAMETER_TYPE_DIMENSION:
active=stp_check_dimension_parameter(c->vars,c->optionname,STP_PARAMETER_DEFAULTED);
step=1.0;
break;
default:
break;
}
stp_parameter_description_destroy(&desc);
if(c->checkbutton)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c->checkbutton),active);
g_signal_connect(G_OBJECT(c->checkbutton),"toggled",G_CALLBACK(stpui_toggle_changed),c);
}
c->scale=gtk_hscale_new_with_range(0,1.0,step);
gtk_scale_set_draw_value(GTK_SCALE(c->scale),FALSE);
switch(desc.p_type)
{
case STP_PARAMETER_TYPE_DOUBLE:
case STP_PARAMETER_TYPE_INT:
c->spin=gtk_spin_button_new_with_range(0,1.0,step);
break;
case STP_PARAMETER_TYPE_DIMENSION:
c->spin=dimension_new(0,1.0,UNIT_POINTS);
dimension_show_unit(DIMENSION(c->spin));
break;
default:
break;
}
g_signal_connect(GTK_WIDGET(c->scale),"button-release-event",G_CALLBACK(stpui_slider_released),c);
g_signal_connect(GTK_WIDGET(c->spin),"button-release-event",G_CALLBACK(stpui_spin_released),c);
g_signal_connect(GTK_WIDGET(c->scale),"value-changed",G_CALLBACK(stpui_slider_changed),c);
g_signal_connect(GTK_WIDGET(c->spin),"value-changed",G_CALLBACK(stpui_spin_changed),c);
stpui_slider_refresh(c);
gtk_box_pack_start(GTK_BOX(c),GTK_WIDGET(c->scale),TRUE,TRUE,0);
gtk_widget_show(c->scale);
gtk_box_pack_start(GTK_BOX(c),GTK_WIDGET(c->spin),FALSE,TRUE,0);
gtk_widget_show(c->spin);
return(GTK_WIDGET(c));
}