static void gnc_recurrence_init( GncRecurrence *gr ) { GtkVBox *vb; GtkHBox *hb; GtkWidget *w; GtkBuilder *builder; recurrenceSet(&gr->recurrence, 1, PERIOD_MONTH, NULL, WEEKEND_ADJ_NONE); /* Open up the builder file */ builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "gnc-recurrence.glade", "GCB_PeriodType_liststore"); gnc_builder_add_from_file (builder, "gnc-recurrence.glade", "GSB_Mult_Adj"); gnc_builder_add_from_file (builder, "gnc-recurrence.glade", "RecurrenceEntryVBox"); vb = GTK_VBOX(gtk_builder_get_object (builder, "RecurrenceEntryVBox")); hb = GTK_HBOX(gtk_builder_get_object (builder, "Startdate_hbox")); w = gnc_date_edit_new (gnc_time (NULL), FALSE, FALSE); gr->gde_start = w; gtk_box_pack_start (GTK_BOX (hb), w, TRUE, TRUE, 0); gtk_widget_show (w); gtk_widget_set_no_show_all(GTK_WIDGET(gr->gde_start), TRUE); gr->gcb_period = GTK_COMBO_BOX(gtk_builder_get_object (builder, "GCB_PeriodType")); gr->gsb_mult = GTK_SPIN_BUTTON(gtk_builder_get_object (builder, "GSB_Mult")); gr->gcb_eom = GTK_CHECK_BUTTON(gtk_builder_get_object (builder, "GCB_EndOfMonth")); gr->nth_weekday = GTK_CHECK_BUTTON(gtk_builder_get_object (builder, "GCB_NthWeekday")); gtk_widget_set_no_show_all(GTK_WIDGET(gr->gcb_eom), TRUE); gtk_widget_set_no_show_all(GTK_WIDGET(gr->nth_weekday), TRUE); gtk_container_add( GTK_CONTAINER(&gr->widget), GTK_WIDGET(vb) ); gnc_recurrence_set(gr, &gr->recurrence); something_changed( GTK_WIDGET(gr), gr); /* Setup the signals */ g_signal_connect( G_OBJECT(gr->gde_start), "date_changed", G_CALLBACK(something_changed), gr ); g_signal_connect( G_OBJECT(gr->gcb_period), "changed", G_CALLBACK(something_changed), gr ); g_signal_connect( G_OBJECT(gr->gsb_mult), "value-changed", G_CALLBACK(something_changed), gr ); g_signal_connect( G_OBJECT(gr->gcb_eom), "toggled", G_CALLBACK(something_changed), gr ); g_signal_connect( G_OBJECT(gr->nth_weekday), "toggled", G_CALLBACK(something_changed), gr ); gtk_widget_show_all( GTK_WIDGET(&gr->widget) ); gtk_builder_connect_signals(builder, gr); g_object_unref(G_OBJECT(builder)); }
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); }
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); }
void update_lockkey_button_state(GtkToggleButton *togglebutton) { GtkWindow *window = NULL; GtkCheckButton *uselockCheckBtn = NULL; GtkButton *lockPWDBtn = NULL; dbg_out("here\n"); window = GTK_WINDOW(lookup_widget(GTK_WIDGET(togglebutton), "securityConfig")); g_assert(window != NULL); uselockCheckBtn = GTK_CHECK_BUTTON(lookup_widget(GTK_WIDGET(window), "useLockCBtn")); g_assert(uselockCheckBtn != NULL); lockPWDBtn = GTK_BUTTON(lookup_widget(GTK_WIDGET(window), "lockPWDBtn")); g_assert(lockPWDBtn != NULL); /* * 錠を使用しない場合は, パスワード設定ボタンを有効化しない. */ #if defined(USE_OPENSSL) if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(uselockCheckBtn))) gtk_widget_set_sensitive(GTK_WIDGET(lockPWDBtn), TRUE); else gtk_widget_set_sensitive(GTK_WIDGET(lockPWDBtn), FALSE); #else gtk_widget_set_sensitive(GTK_WIDGET(lockPWDBtn), FALSE); #endif /* USE_OPENSSL */ return; }
void update_rsa_encryption_button_state(GtkToggleButton *togglebutton) { GtkWindow *window = NULL; GtkCheckButton *encryptionCheckBtn = NULL; GtkButton *pubkeyPWDBtn = NULL; dbg_out("here\n"); window = GTK_WINDOW(lookup_widget(GTK_WIDGET(togglebutton), "securityConfig")); g_assert(window != NULL); encryptionCheckBtn = GTK_CHECK_BUTTON(lookup_widget(GTK_WIDGET(window), "RSAKeyEncryptionCBtn")); g_assert(encryptionCheckBtn != NULL); pubkeyPWDBtn = GTK_BUTTON(lookup_widget(GTK_WIDGET(window), "pubkeyPWDBtn")); g_assert(pubkeyPWDBtn != NULL); /* * パスワードを使用しない場合は, パスワード設定ボタンを有効化しない. */ #if defined(USE_OPENSSL) if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(encryptionCheckBtn))) gtk_widget_set_sensitive(GTK_WIDGET(pubkeyPWDBtn), TRUE); else gtk_widget_set_sensitive(GTK_WIDGET(pubkeyPWDBtn), FALSE); #else gtk_widget_set_sensitive(GTK_WIDGET(pubkeyPWDBtn), FALSE); #endif /* USE_OPENSSL */ return; }
void AP_UnixDialog_Paragraph::_populateWindowData(void) { // alignment option menu UT_ASSERT(m_listAlignment); XAP_comboBoxSetActiveFromIntCol(GTK_COMBO_BOX(m_listAlignment), 1, (gint) _getMenuItemValue(id_MENU_ALIGNMENT)); // indent and paragraph margins UT_ASSERT(m_spinbuttonLeft); gtk_entry_set_text(GTK_ENTRY(m_spinbuttonLeft), (const gchar *) _getSpinItemValue(id_SPIN_LEFT_INDENT)); UT_ASSERT(m_spinbuttonRight); gtk_entry_set_text(GTK_ENTRY(m_spinbuttonRight), (const gchar *) _getSpinItemValue(id_SPIN_RIGHT_INDENT)); UT_ASSERT(m_spinbuttonBy); gtk_entry_set_text(GTK_ENTRY(m_spinbuttonBy), (const gchar *) _getSpinItemValue(id_SPIN_SPECIAL_INDENT)); UT_ASSERT(m_listSpecial); XAP_comboBoxSetActiveFromIntCol(GTK_COMBO_BOX(m_listSpecial), 1, (gint) _getMenuItemValue(id_MENU_SPECIAL_INDENT)); // spacing UT_ASSERT(m_spinbuttonLeft); gtk_entry_set_text(GTK_ENTRY(m_spinbuttonBefore), (const gchar *) _getSpinItemValue(id_SPIN_BEFORE_SPACING)); UT_ASSERT(m_spinbuttonRight); gtk_entry_set_text(GTK_ENTRY(m_spinbuttonAfter), (const gchar *) _getSpinItemValue(id_SPIN_AFTER_SPACING)); UT_ASSERT(m_spinbuttonAt); gtk_entry_set_text(GTK_ENTRY(m_spinbuttonAt), (const gchar *) _getSpinItemValue(id_SPIN_SPECIAL_SPACING)); UT_ASSERT(m_listLineSpacing); XAP_comboBoxSetActiveFromIntCol(GTK_COMBO_BOX(m_listLineSpacing), 1, (gint) _getMenuItemValue(id_MENU_SPECIAL_SPACING)); // set the check boxes // TODO : handle tri-state boxes !!! gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonWidowOrphan)), (_getCheckItemValue(id_CHECK_WIDOW_ORPHAN) == check_TRUE)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonKeepLines)), (_getCheckItemValue(id_CHECK_KEEP_LINES) == check_TRUE)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonPageBreak)), (_getCheckItemValue(id_CHECK_PAGE_BREAK) == check_TRUE)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonSuppress)), (_getCheckItemValue(id_CHECK_SUPPRESS) == check_TRUE)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonHyphenate)), (_getCheckItemValue(id_CHECK_NO_HYPHENATE) == check_TRUE)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonKeepNext)), (_getCheckItemValue(id_CHECK_KEEP_NEXT) == check_TRUE)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonDomDirection)), (_getCheckItemValue(id_CHECK_DOMDIRECTION) == check_TRUE)); }
void init_auth(GtkBuilder *builder) { auth_widget.auth_user_search = GTK_ENTRY(gtk_builder_get_object(builder, "auth_entry")); auth_widget.auth_col.auth_id = GTK_CELL_RENDERER_TEXT(gtk_builder_get_object(builder, "auth_id")); auth_widget.auth_col.auth_name = GTK_CELL_RENDERER_TEXT(gtk_builder_get_object(builder, "auth_name")); auth_widget.auth_col.auth_u = GTK_CELL_RENDERER_TEXT(gtk_builder_get_object(builder, "auth_u")); auth_widget.auth_col.auth_m = GTK_CELL_RENDERER_TEXT(gtk_builder_get_object(builder, "auth_m")); auth_widget.auth_col.auth_o = GTK_CELL_RENDERER_TEXT(gtk_builder_get_object(builder, "auth_o")); auth_widget.auth_col.auth_a = GTK_CELL_RENDERER_TEXT(gtk_builder_get_object(builder, "auth_a")); auth_widget.auth_col.auth_t = GTK_CELL_RENDERER_TEXT(gtk_builder_get_object(builder, "auth_t")); g_object_set_data(G_OBJECT(auth_widget.auth_col.auth_u), "column", GINT_TO_POINTER(COLUMN_AUTH_U)); g_object_set_data(G_OBJECT(auth_widget.auth_col.auth_m), "column", GINT_TO_POINTER(COLUMN_AUTH_M)); g_object_set_data(G_OBJECT(auth_widget.auth_col.auth_o), "column", GINT_TO_POINTER(COLUMN_AUTH_O)); g_object_set_data(G_OBJECT(auth_widget.auth_col.auth_a), "column", GINT_TO_POINTER(COLUMN_AUTH_A)); g_object_set_data(G_OBJECT(auth_widget.auth_col.auth_t), "column", GINT_TO_POINTER(COLUMN_AUTH_T)); auth_widget.u_box = GTK_BOX(gtk_builder_get_object(builder, "u_box")); auth_widget.m_box = GTK_BOX(gtk_builder_get_object(builder, "m_box")); auth_widget.o_box = GTK_BOX(gtk_builder_get_object(builder, "o_box")); auth_widget.a_box = GTK_BOX(gtk_builder_get_object(builder, "a_box")); auth_widget.t_box = GTK_BOX(gtk_builder_get_object(builder, "t_box")); auth_widget.edit_u = GTK_CHECK_BUTTON(gtk_builder_get_object(builder, "check_u")); auth_widget.edit_m = GTK_CHECK_BUTTON(gtk_builder_get_object(builder, "check_m")); auth_widget.edit_a = GTK_CHECK_BUTTON(gtk_builder_get_object(builder, "check_a")); auth_widget.applybtn = GTK_BUTTON(gtk_builder_get_object(builder, "auth_btn")); auth_widget.checkbtn = GTK_CHECK_BUTTON(gtk_builder_get_object(builder, "c_btn")); auth_widget.s_u = GTK_LABEL(gtk_builder_get_object(builder, "show_u")); }
static void gtk_check_button_finalize (GObject *object) { GtkCheckButtonPrivate *priv = gtk_check_button_get_instance_private (GTK_CHECK_BUTTON (object)); g_clear_pointer (&priv->indicator_widget, gtk_widget_unparent); G_OBJECT_CLASS (gtk_check_button_parent_class)->finalize (object); }
static void gtk_check_button_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { switch (prop_id) { case PROP_DRAW_INDICATOR: g_value_set_boolean (value, gtk_check_button_get_draw_indicator (GTK_CHECK_BUTTON (object))); break; case PROP_INCONSISTENT: g_value_set_boolean (value, gtk_check_button_get_inconsistent (GTK_CHECK_BUTTON (object))); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
void my_bool_listener (PluginParam *param) { GtkCheckButton *editable; if (sdlGoom->config_win == 0) return; editable = GTK_CHECK_BUTTON(param->user_data); if (editable) { if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(editable)) != BVAL(*param)) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable),BVAL(*param)); } }
static void configure_win_ok_cb(GtkWidget * w, gpointer data) { jack_cfg.isTraceEnabled = (gint) GTK_CHECK_BUTTON(GTK_isTraceEnabled)->toggle_button.active; jack_cfg.port_connection_mode = GET_CHARS(GTK_COMBO(port_connection_mode_combo)->entry); jack_set_port_connection_mode(); /* update the connection mode */ mlp_set_bool ("jack", "isTraceEnabled", jack_cfg.isTraceEnabled); mlp_set_string ("jack", "port_connection_mode", jack_cfg.port_connection_mode); gtk_widget_destroy(configure_win); }
static GtkCList *mmio_window_add_page( mmio_window_t mmio, char *name, struct mmio_region *io_rgn ) { GtkCList *list; GtkWidget *scroll; GtkWidget *tab; GtkCheckButton *trace_button; GtkVBox *vbox; scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS ); list = GTK_CLIST(gtk_clist_new(5)); gtk_clist_set_column_width(list, 0, 70); gtk_clist_set_column_width(list, 1, 75); gtk_clist_set_column_width(list, 2, 70); gtk_clist_set_column_width(list, 3, 280); gtk_clist_set_column_width(list, 4, 160); gtk_clist_set_column_justification(list, 0, GTK_JUSTIFY_CENTER ); gtk_clist_set_column_justification(list, 2, GTK_JUSTIFY_CENTER ); gtk_clist_set_column_justification(list, 3, GTK_JUSTIFY_CENTER ); gtk_clist_set_column_title(list, 0, _("Address")); gtk_clist_set_column_title(list, 1, _("Register")); gtk_clist_set_column_title(list, 2, _("Value")); gtk_clist_set_column_title(list, 3, _("Bit Pattern")); gtk_clist_set_column_title(list, 4, _("Description")); gtk_clist_column_titles_show(list); gtk_widget_modify_font( GTK_WIDGET(list), gui_fixed_font ); tab = gtk_label_new(_(name)); gtk_container_add( GTK_CONTAINER(scroll), GTK_WIDGET(list) ); vbox = GTK_VBOX(gtk_vbox_new( FALSE, 0 )); gtk_container_add( GTK_CONTAINER(vbox), GTK_WIDGET(scroll) ); trace_button = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Trace access"))); if( io_rgn != NULL ) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(trace_button), io_rgn->trace_flag ? TRUE : FALSE); } gtk_container_add( GTK_CONTAINER(vbox), GTK_WIDGET(trace_button) ); gtk_box_set_child_packing( GTK_BOX(vbox), GTK_WIDGET(trace_button), FALSE, FALSE, 0, GTK_PACK_START ); gtk_notebook_append_page( GTK_NOTEBOOK(mmio->notebook), GTK_WIDGET(vbox), tab ); gtk_object_set_data( GTK_OBJECT(mmio->window), name, list ); g_signal_connect ((gpointer) trace_button, "toggled", G_CALLBACK (on_trace_button_toggled), io_rgn); return list; }
static void konepuremilitary_anglesnap_frame_init(KonepuremilitaryAnglesnapFrame *frame) { KonepuremilitaryAnglesnapFramePrivate *priv = KONEPUREMILITARY_ANGLESNAP_FRAME_GET_PRIVATE(frame); GtkWidget *hbox; frame->priv = priv; hbox = gtk_hbox_new(FALSE, 0); priv->scale = scale_new(); priv->flag = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Active"))); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->flag), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->scale), TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_frame_set_label(GTK_FRAME(frame), _("Angle snapping")); }
/** * g_paste_settings_ui_panel_add_boolean_setting: * @self: a #GPasteSettingsUiPanel instance * @label: the label to display * @value: the deafault value * @on_value_changed: (closure user_data) (scope notified): the callback to call when the value changes * * Add a new boolean settings to the current pane * * Returns: (transfer none): the #GtkCheckButton we just added */ G_PASTE_VISIBLE GtkCheckButton * g_paste_settings_ui_panel_add_boolean_setting (GPasteSettingsUiPanel *self, const gchar *label, gboolean value, GPasteBooleanCallback on_value_changed, gpointer user_data) { GtkWidget *button = gtk_check_button_new_with_mnemonic (label); CALLBACK_DATA_DEFAULT (button) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), value); _data->signal = g_signal_connect (button, "toggled", G_CALLBACK (boolean_wrapper), data); gtk_grid_attach (GTK_GRID (self), button, 0, self->priv->current_line++, 1, 1); return GTK_CHECK_BUTTON (button); }
static void konepuremilitary_sensor_alignment_frame_init(KonepuremilitarySensorAlignmentFrame *frame) { KonepuremilitarySensorAlignmentFramePrivate *priv = KONEPUREMILITARY_SENSOR_ALIGNMENT_FRAME_GET_PRIVATE(frame); GtkWidget *hbox; frame->priv = priv; hbox = gtk_hbox_new(FALSE, 0); priv->scale = scale_new(); priv->flag = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Active"))); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->flag), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->scale), TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_frame_set_label(GTK_FRAME(frame), _("Sensor alignment")); }
void ssh_createdialog(GtkWidget *widget) { GtkWidget *vbox; GtkWidget *tbl; GtkWidget *l1, *l2; vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), 10); gtk_container_add(GTK_CONTAINER(widget), vbox); gtk_widget_show(vbox); check_enablessh = gtk_check_button_new_with_label( _("Enable SSH tunneling")); gtk_box_pack_start(GTK_BOX(vbox), check_enablessh, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(GTK_CHECK_BUTTON(check_enablessh)), "toggled", G_CALLBACK(sig_enablessh), NULL); gtk_widget_show(check_enablessh); tbl = gtk_grid_new(); gtk_container_set_border_width(GTK_CONTAINER(tbl), 10); gtk_grid_set_row_spacing(GTK_GRID(tbl), 5); gtk_grid_set_column_spacing(GTK_GRID(tbl), 10); gtk_box_pack_start(GTK_BOX(vbox), tbl, TRUE, TRUE, 5); gtk_widget_show(tbl); l1 = gtk_label_new(_("Username:"******"changed", G_CALLBACK(sig_sshuser), NULL); gtk_grid_attach(GTK_GRID(tbl), input_user, 1, 0, 1, 1); gtk_widget_show(input_user); l2 = gtk_label_new(_("Hostname:")); gtk_grid_attach(GTK_GRID(tbl), l2, 0, 1, 1, 1); gtk_widget_show(l2); input_host = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(input_host), 255); g_signal_connect(G_OBJECT(GTK_ENTRY(input_host)), "changed", G_CALLBACK(sig_sshhost), NULL); gtk_grid_attach(GTK_GRID(tbl), input_host, 1, 1, 1, 1); gtk_widget_show(input_host); }
static void gtk_check_button_measure (GtkWidget *widget, GtkOrientation orientation, int for_size, int *minimum, int *natural, int *minimum_baseline, int *natural_baseline) { GtkCheckButtonPrivate *priv = gtk_check_button_get_instance_private (GTK_CHECK_BUTTON (widget)); GtkWidget *child; int indicator_min = 0; int indicator_nat = 0; int child_min = 0; int child_nat = 0; *minimum = 0; *natural = 0; if (priv->draw_indicator) { gtk_widget_measure (priv->indicator_widget, orientation, for_size, &indicator_min, &indicator_nat, NULL, NULL); } child = gtk_bin_get_child (GTK_BIN (widget)); if (child) { gtk_widget_measure (child, orientation, for_size, &child_min, &child_nat, minimum_baseline, natural_baseline); } if (orientation == GTK_ORIENTATION_HORIZONTAL) { *minimum = indicator_min + child_min; *natural = indicator_nat + child_nat; } else /* VERTICAL */ { *minimum = MAX (indicator_min, child_min); *natural = MAX (indicator_nat, child_nat); } }
static void gtk_check_button_size_allocate (GtkWidget *widget, int width, int height, int baseline) { GtkCheckButtonPrivate *priv = gtk_check_button_get_instance_private (GTK_CHECK_BUTTON (widget)); GtkAllocation child_alloc = { 0 }; GtkWidget *child; gboolean is_rtl = _gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL; int x = 0; if (priv->draw_indicator) { child_alloc.y = 0; child_alloc.height = height; gtk_widget_measure (priv->indicator_widget, GTK_ORIENTATION_HORIZONTAL, -1, &child_alloc.width, NULL, NULL, NULL); if (is_rtl) { x = 0; child_alloc.x = width - child_alloc.width; } else { x = child_alloc.width; child_alloc.x = 0; } gtk_widget_size_allocate (priv->indicator_widget, &child_alloc, baseline); } child = gtk_bin_get_child (GTK_BIN (widget)); if (child) { child_alloc.x = x; child_alloc.y = 0; child_alloc.width = width - child_alloc.width; /* Indicator width */ child_alloc.height = height; gtk_widget_size_allocate (child, &child_alloc, baseline); } }
void AP_UnixDialog_Paragraph::event_CheckToggled(GtkWidget * widget) { UT_ASSERT(widget); tControl id = (tControl) GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), WIDGET_ID_TAG)); gboolean state = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(widget))); tCheckState cs; // TODO : handle tri-state boxes !!! if (state == TRUE) cs = check_TRUE; else cs = check_FALSE; _setCheckItemValue(id, cs); }
static void roccat_single_cpi_selector_init(RoccatSingleCpiSelector *selector) { RoccatSingleCpiSelectorPrivate *priv = ROCCAT_SINGLE_CPI_SELECTOR_GET_PRIVATE(selector); GtkHBox *hbox; selector->priv = priv; hbox = GTK_HBOX(gtk_hbox_new(FALSE, 0)); gtk_container_add(GTK_CONTAINER(selector), GTK_WIDGET(hbox)); priv->radio = GTK_RADIO_BUTTON(gtk_radio_button_new(NULL)); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->radio), FALSE, FALSE, 0); g_signal_connect(G_OBJECT(priv->radio), "toggled", G_CALLBACK(click_radio_cb), selector); priv->active = GTK_CHECK_BUTTON(gtk_check_button_new()); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->active), FALSE, FALSE, 0); g_signal_connect(G_OBJECT(priv->active), "toggled", G_CALLBACK(toggle_active_cb), selector); priv->scale = GAMINGGEAR_HSCALE(gaminggear_hscale_new_with_range(0, 1, 1)); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->scale), TRUE, TRUE, 0); }
static void gtk_check_button_direction_changed (GtkWidget *widget, GtkTextDirection previous_direction) { GtkCheckButtonPrivate *priv = gtk_check_button_get_instance_private (GTK_CHECK_BUTTON (widget)); if (!priv->indicator_widget) return; if (previous_direction == GTK_TEXT_DIR_LTR) { /* Now RTL -> Move the indicator to the right */ gtk_widget_insert_before (priv->indicator_widget, widget, NULL); } else { /* Now LTR -> Move the indicator to the left */ gtk_widget_insert_after (priv->indicator_widget, widget, NULL); } }
static GObject *konepuremilitary_single_cpi_selector_constructor(GType gtype, guint n_properties, GObjectConstructParam *properties) { KonepuremilitarySingleCpiSelectorPrivate *priv; KonepuremilitarySingleCpiSelector *selector; GObject *obj; obj = G_OBJECT_CLASS(konepuremilitary_single_cpi_selector_parent_class)->constructor(gtype, n_properties, properties); selector = KONEPUREMILITARY_SINGLE_CPI_SELECTOR(obj); priv = selector->priv; priv->radio = GTK_RADIO_BUTTON(gtk_radio_button_new(NULL)); gtk_box_pack_start(GTK_BOX(selector), GTK_WIDGET(priv->radio), FALSE, FALSE, 0); g_signal_connect(G_OBJECT(priv->radio), "toggled", G_CALLBACK(click_radio_cb), selector); priv->active = GTK_CHECK_BUTTON(gtk_check_button_new()); gtk_box_pack_start(GTK_BOX(selector), GTK_WIDGET(priv->active), FALSE, FALSE, 0); g_signal_connect(G_OBJECT(priv->active), "toggled", G_CALLBACK(toggle_active_cb), selector); priv->scale = GAMINGGEAR_XY_SCALES(gaminggear_xy_scales_new(priv->min, priv->max, priv->step)); gtk_box_pack_start(GTK_BOX(selector), GTK_WIDGET(priv->scale), TRUE, TRUE, 0); gtk_widget_show_all(GTK_WIDGET(selector)); return obj; }
MidiogreApp *midiogre_app_init(void) { MidiogreApp *app; GtkWidget *header; GtkWidget *separator; GtkWidget *scrolled; GtkWidget *label,*frame; GtkWidget *button; GtkBox *box; gint i; GError *err; /* Allocate app */ app = calloc(1, sizeof(MidiogreApp)); /* Setup window */ app->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL)); gtk_window_set_default_size(GTK_WINDOW(app->window), 600, 400); g_signal_connect(app->window, "destroy", G_CALLBACK(gtk_widget_destroyed), NULL); g_signal_connect(app->window, "key-release-event", G_CALLBACK(key_event), NULL); gtk_window_set_icon(app->window,gdk_pixbuf_new_from_resource("/org/prozum/midiogre/midiogre_logo.png",&err)); /* Setup header bar */ header = gtk_header_bar_new(); gtk_header_bar_set_title (GTK_HEADER_BAR(header), "Midiogre"); gtk_window_set_titlebar(app->window, header); /* Setup close button */ button = gtk_button_new(); gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/window-close-symbolic.symbolic.png")); gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button); g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_main_quit), app->window); /* Add seperator */ separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL); gtk_header_bar_pack_end(GTK_HEADER_BAR(header), separator); /* Setup folder button */ button = gtk_button_new(); gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/document-open-symbolic.symbolic.png")); gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button); g_signal_connect_swapped(button, "clicked", G_CALLBACK(folder_chooser), app->window); /* Global horizontal box */ app->win_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(app->window), GTK_WIDGET(app->win_box)); /* Scroll container for sidepanel */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(app->win_box, scrolled, FALSE, FALSE, 0); /* Sidepanel box */ app->panel_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0)); gtk_container_add(GTK_CONTAINER (scrolled), GTK_WIDGET(app->panel_box)); gtk_container_set_border_width(GTK_CONTAINER(app->panel_box), 10); /* Frame with favorit info */ frame = gtk_frame_new("Favorite"); gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0); app->fav_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->fav_box)); /* Current favorite */ app->fav_title_label = GTK_LABEL(gtk_label_new("")); gtk_label_set_max_width_chars(app->fav_title_label, 20); gtk_label_set_width_chars(app->fav_title_label, 20); gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_title_label), FALSE, FALSE, 0); app->fav_artist_label = GTK_LABEL(gtk_label_new("No favorite selected!")); gtk_label_set_max_width_chars(app->fav_artist_label, 20); gtk_label_set_width_chars(app->fav_artist_label, 20); gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_artist_label), FALSE, FALSE, 0); app->fav_album_label = GTK_LABEL(gtk_label_new("")); gtk_label_set_max_width_chars(app->fav_album_label, 20); gtk_label_set_width_chars(app->fav_album_label, 20); gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_album_label), FALSE, FALSE, 0); /* Frame with search criteria widgets */ frame = gtk_frame_new("Search"); gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0); app->search_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 10)); gtk_container_set_border_width(GTK_CONTAINER(app->search_box), 10); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->search_box)); /* Title entry */ frame = gtk_frame_new("Title"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->title_entry = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(app->title_entry), TRUE, FALSE, 0); /* Artist entry */ frame = gtk_frame_new("Artist"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(box), 10); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->artist_entry = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(app->artist_entry), TRUE, FALSE, 0); /* Album entry */ frame = gtk_frame_new("Album"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->album_entry = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(app->album_entry), TRUE, FALSE, 0); /* Instrument class buttons */ frame = gtk_frame_new("Instrument Classes"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); app->instr_grid = GTK_GRID(gtk_grid_new()); #if GTK_MINOR_VERSION >= 12 gtk_widget_set_margin_start(GTK_WIDGET(app->instr_grid), 10); gtk_widget_set_margin_end(GTK_WIDGET(app->instr_grid), 10); #else gtk_widget_set_margin_left(GTK_WIDGET(app->instr_grid), 10); gtk_widget_set_margin_right(GTK_WIDGET(app->instr_grid), 10); #endif gtk_widget_set_margin_bottom(GTK_WIDGET(app->instr_grid), 10); gtk_widget_set_margin_top(GTK_WIDGET(app->instr_grid), 10); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->instr_grid)); for (i = 0; i < INSTR_CLASSES; i++) { label = gtk_label_new(instrument_classes[i]); gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START); gtk_grid_attach(app->instr_grid, label, 1, i + 1, 1, 1); app->instr_buttons[i] = GTK_CHECK_BUTTON(gtk_check_button_new()); gtk_widget_set_halign(GTK_WIDGET(app->instr_buttons[i]), GTK_ALIGN_END); gtk_grid_attach(app->instr_grid, GTK_WIDGET(app->instr_buttons[i]), 2, i + 1, 1, 1); } /* Result spinbutton */ frame = gtk_frame_new("Max result"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->result_spinbutton = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 100, 1)); gtk_spin_button_set_value(app->result_spinbutton, 25); gtk_box_pack_start(box, GTK_WIDGET(app->result_spinbutton), TRUE, TRUE, 0); /* Search button */ app->search_button = GTK_BUTTON(gtk_button_new_with_label("Search")); gtk_box_pack_start(app->search_box, GTK_WIDGET(app->search_button), FALSE, FALSE, 0); g_signal_connect_swapped(app->search_button, "clicked", G_CALLBACK(search_event), app); /* Songboxes notebook (Tabsview) */ app->song_notebook = GTK_NOTEBOOK(gtk_notebook_new()); gtk_widget_set_hexpand(GTK_WIDGET(app->song_notebook), TRUE); gtk_box_pack_start(app->win_box, GTK_WIDGET(app->song_notebook), TRUE, TRUE, 0); /* Add song boxes */ app->songboxes[SONGBOX_ALPHA] = songbox_new(app->song_notebook, "Alphabetical"); app->songboxes[SONGBOX_FPRNT] = songbox_new(app->song_notebook, "Fingerprint"); app->songboxes[SONGBOX_BEST] = songbox_new(app->song_notebook, "Best Match"); app->songboxes[SONGBOX_POP] = songbox_new(app->song_notebook, "Popularity"); app->songboxes[SONGBOX_NEW] = songbox_new(app->song_notebook, "Newest"); /* Show all widgets */ gtk_widget_show_all(GTK_WIDGET(app->window)); /* Allocate song queue */ app->songs[SONGBOX_ALPHA] = g_queue_new(); app->songs[SONGBOX_FPRNT] = g_queue_new(); app->songs[SONGBOX_BEST] = g_queue_new(); app->songs[SONGBOX_POP] = g_queue_new(); app->songs[SONGBOX_NEW] = g_queue_new(); return app; }
void gui_init (dt_imageio_module_storage_t *self) { self->gui_data = (dt_storage_flickr_gui_data_t *)g_malloc(sizeof(dt_storage_flickr_gui_data_t)); memset(self->gui_data,0,sizeof(dt_storage_flickr_gui_data_t)); dt_storage_flickr_gui_data_t *ui= self->gui_data; self->widget = gtk_vbox_new(FALSE, 0); GtkWidget *hbox1=gtk_hbox_new(FALSE,5); GtkWidget *hbox0=gtk_hbox_new(FALSE,5); GtkWidget *vbox1=gtk_vbox_new(FALSE,0); GtkWidget *vbox2=gtk_vbox_new(FALSE,5); ui->label1 = GTK_LABEL( gtk_label_new( _("flickr user") ) ); ui->label3 = GTK_LABEL( gtk_label_new( _("photosets") ) ); ui->labelPerms = GTK_LABEL( gtk_label_new( _("visible to") ) ); ui->label4 = GTK_LABEL( gtk_label_new( NULL ) ); set_status(ui,_("click login button to start"), "#ffffff"); ui->label5 = GTK_LABEL( gtk_label_new( _("title") ) ); ui->label6 = GTK_LABEL( gtk_label_new( _("summary") ) ); gtk_misc_set_alignment(GTK_MISC(ui->label1), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->labelPerms), 0.0, 0.9); gtk_misc_set_alignment(GTK_MISC(ui->label3), 0.0, 0.7); gtk_misc_set_alignment(GTK_MISC(ui->label5), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label6), 0.0, 0.5); ui->entry1 = GTK_ENTRY( gtk_entry_new() ); ui->entry3 = GTK_ENTRY( gtk_entry_new() ); // Album title ui->entry4 = GTK_ENTRY( gtk_entry_new() ); // Album summary dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry1)); dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry3)); dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry4)); /* gtk_widget_add_events(GTK_WIDGET(ui->entry1), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry1), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry1), "focus-out-event", G_CALLBACK(focus_out), NULL); gtk_widget_add_events(GTK_WIDGET(ui->entry2), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry2), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry2), "focus-out-event", G_CALLBACK(focus_out), NULL); gtk_widget_add_events(GTK_WIDGET(ui->entry3), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry3), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry3), "focus-out-event", G_CALLBACK(focus_out), NULL); gtk_widget_add_events(GTK_WIDGET(ui->entry4), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry4), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry4), "focus-out-event", G_CALLBACK(focus_out), NULL); */ GHashTable* table = dt_pwstorage_get("flickr"); gchar* _username = g_strdup( g_hash_table_lookup(table, "username")); g_hash_table_destroy(table); gtk_entry_set_text( ui->entry1, _username == NULL?"":_username ); gtk_entry_set_text( ui->entry3, _("my new photoset") ); gtk_entry_set_text( ui->entry4, _("exported from darktable") ); GtkWidget *albumlist=gtk_hbox_new(FALSE,0); ui->comboBox1 = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new()); // Available albums dt_ellipsize_combo(GTK_COMBO_BOX(ui->comboBox1)); ui->dtbutton1 = DTGTK_BUTTON( dtgtk_button_new(dtgtk_cairo_paint_refresh,0) ); g_object_set(G_OBJECT(ui->dtbutton1), "tooltip-text", _("refresh album list"), (char *)NULL); ui->button = GTK_BUTTON(gtk_button_new_with_label(_("login"))); g_object_set(G_OBJECT(ui->button), "tooltip-text", _("flickr login"), (char *)NULL); gtk_widget_set_sensitive( GTK_WIDGET(ui->comboBox1), FALSE); gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(ui->comboBox1), combobox_separator,ui->comboBox1,NULL); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox1), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->dtbutton1), FALSE, FALSE, 0); ui->checkButton2 = GTK_CHECK_BUTTON( gtk_check_button_new_with_label(_("export tags")) ); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON( ui->checkButton2 ),TRUE); ui->permsComboBox = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new()); gtk_combo_box_text_append_text(ui->permsComboBox, _("you")); gtk_combo_box_text_append_text(ui->permsComboBox, _("friends")); gtk_combo_box_text_append_text(ui->permsComboBox, _("family")); gtk_combo_box_text_append_text(ui->permsComboBox, _("friends + family")); gtk_combo_box_text_append_text(ui->permsComboBox, _("everyone")); gtk_combo_box_set_active(GTK_COMBO_BOX(ui->permsComboBox), 0); // Set default permission to private gtk_box_pack_start(GTK_BOX(self->widget), hbox0, TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->label1 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->entry1 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->button ), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX( hbox1 ), vbox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX( hbox1 ), vbox2, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( gtk_label_new("")), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->labelPerms ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label3 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->label4 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->checkButton2 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->permsComboBox ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( albumlist ), TRUE, FALSE, 0); // Create Album ui->hbox1=GTK_BOX(gtk_hbox_new(FALSE,5)); gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox1), TRUE); vbox1=gtk_vbox_new(FALSE,0); vbox2=gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox2, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox1), TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label5 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label6 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry3 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry4 ), TRUE, FALSE, 0); // Setup signals // add signal on realize and hide gtk_widget_hide(GTK_WIDGET(ui->hbox1)); g_signal_connect(G_OBJECT(ui->dtbutton1), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui); g_signal_connect(G_OBJECT(ui->button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui); g_signal_connect(G_OBJECT(ui->entry1), "changed", G_CALLBACK(flickr_entry_changed), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox1), "changed", G_CALLBACK(flickr_album_changed), (gpointer)ui); /** dont' populate the combo on startup, save 3 second // If username and password is stored, let's populate the combo if( _username && _password ) { ui->user_token = _password; refresh_albums(ui); } */ if( _username ) g_free (_username); gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox1), 0); }
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; } }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_exposure_gui_data_t)); dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data; dt_iop_exposure_params_t *p = (dt_iop_exposure_params_t *)self->params; g->modes = NULL; g->deflicker_histogram_sources = NULL; g->deflicker_histogram = NULL; dt_pthread_mutex_init(&g->lock, NULL); /* register hooks with current dev so that histogram can interact with this module. */ darktable.develop->proxy.exposure.module = self; darktable.develop->proxy.exposure.set_white = dt_iop_exposure_set_white; darktable.develop->proxy.exposure.get_white = dt_iop_exposure_get_white; darktable.develop->proxy.exposure.set_black = dt_iop_exposure_set_black; darktable.develop->proxy.exposure.get_black = dt_iop_exposure_get_black; self->request_color_pick = DT_REQUEST_COLORPICK_OFF; self->widget = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE)); g->mode = dt_bauhaus_combobox_new(self); dt_bauhaus_widget_set_label(g->mode, NULL, _("mode")); dt_bauhaus_combobox_add(g->mode, C_("mode", "manual")); g->modes = g_list_append(g->modes, GUINT_TO_POINTER(EXPOSURE_MODE_MANUAL)); dt_bauhaus_combobox_add(g->mode, _("automatic")); g->modes = g_list_append(g->modes, GUINT_TO_POINTER(EXPOSURE_MODE_DEFLICKER)); dt_bauhaus_combobox_set_default(g->mode, 0); dt_bauhaus_combobox_set(g->mode, g_list_index(g->modes, GUINT_TO_POINTER(p->mode))); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->mode), TRUE, TRUE, 0); g->black = dt_bauhaus_slider_new_with_range(self, -0.1, 0.1, .001, p->black, 4); g_object_set(G_OBJECT(g->black), "tooltip-text", _("adjust the black level"), (char *)NULL); dt_bauhaus_slider_set_format(g->black, "%.4f"); dt_bauhaus_widget_set_label(g->black, NULL, _("black")); dt_bauhaus_slider_enable_soft_boundaries(g->black, -1.0, 1.0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->black), TRUE, TRUE, 0); g->mode_stack = gtk_stack_new(); gtk_stack_set_homogeneous(GTK_STACK(g->mode_stack),FALSE); gtk_box_pack_start(GTK_BOX(self->widget), g->mode_stack, TRUE, TRUE, 0); GtkWidget *vbox_manual = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE)); g->exposure = dt_bauhaus_slider_new_with_range(self, -3.0, 3.0, .02, p->exposure, 3); g_object_set(G_OBJECT(g->exposure), "tooltip-text", _("adjust the exposure correction"), (char *)NULL); dt_bauhaus_slider_set_format(g->exposure, "%.2fEV"); dt_bauhaus_widget_set_label(g->exposure, NULL, _("exposure")); dt_bauhaus_slider_enable_soft_boundaries(g->exposure, -18.0, 18.0); gtk_box_pack_start(GTK_BOX(vbox_manual), GTK_WIDGET(g->exposure), TRUE, TRUE, 0); GtkBox *hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); g->autoexp = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("auto"))); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoexp), FALSE); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexp), FALSE, TRUE, 0); g->autoexpp = dt_bauhaus_slider_new_with_range(self, 0.0, 0.2, .001, 0.01, 3); g_object_set(G_OBJECT(g->autoexpp), "tooltip-text", _("percentage of bright values clipped out"), (char *)NULL); gtk_widget_set_sensitive(GTK_WIDGET(g->autoexpp), TRUE); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexpp), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_manual), GTK_WIDGET(hbox), TRUE, TRUE, 0); gtk_widget_show_all(vbox_manual); gtk_stack_add_named(GTK_STACK(g->mode_stack), vbox_manual, "manual"); GtkWidget *vbox_deflicker = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE)); g->deflicker_percentile = dt_bauhaus_slider_new_with_range(self, 0, 100, .01, p->deflicker_percentile, 3); // FIXME: this needs a better tooltip! g_object_set(G_OBJECT(g->deflicker_percentile), "tooltip-text", _("percentile"), (char *)NULL); dt_bauhaus_slider_set_format(g->deflicker_percentile, "%.2f%%"); dt_bauhaus_widget_set_label(g->deflicker_percentile, NULL, _("percentile")); gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(g->deflicker_percentile), TRUE, TRUE, 0); g->deflicker_target_level = dt_bauhaus_slider_new_with_range(self, -18.0, 18.0, .01, p->deflicker_target_level, 3); g_object_set(G_OBJECT(g->deflicker_target_level), "tooltip-text", _("target level"), (char *)NULL); dt_bauhaus_slider_set_format(g->deflicker_target_level, "%.2fEV"); dt_bauhaus_widget_set_label(g->deflicker_target_level, NULL, _("target level")); gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(g->deflicker_target_level), TRUE, TRUE, 0); g->deflicker_histogram_source = dt_bauhaus_combobox_new(self); dt_bauhaus_widget_set_label(g->deflicker_histogram_source, NULL, _("histogram of")); dt_bauhaus_combobox_add(g->deflicker_histogram_source, _("pre-processed image")); g->deflicker_histogram_sources = g_list_append(g->deflicker_histogram_sources, GUINT_TO_POINTER(DEFLICKER_HISTOGRAM_SOURCE_THUMBNAIL)); dt_bauhaus_combobox_add(g->deflicker_histogram_source, _("source raw data")); g->deflicker_histogram_sources = g_list_append(g->deflicker_histogram_sources, GUINT_TO_POINTER(DEFLICKER_HISTOGRAM_SOURCE_SOURCEFILE)); dt_bauhaus_combobox_set_default(g->deflicker_histogram_source, DEFLICKER_HISTOGRAM_SOURCE_THUMBNAIL); dt_bauhaus_combobox_set(g->deflicker_histogram_source, g_list_index(g->modes, GUINT_TO_POINTER(p->deflicker_histogram_source))); gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(g->deflicker_histogram_source), TRUE, TRUE, 0); GtkBox *hbox1 = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); GtkLabel *label = GTK_LABEL(gtk_label_new(_("computed EC: "))); gtk_box_pack_start(GTK_BOX(hbox1), GTK_WIDGET(label), FALSE, FALSE, 0); g->deflicker_used_EC = GTK_LABEL(gtk_label_new("")); // This gets filled in by process g_object_set(G_OBJECT(g->deflicker_used_EC), "tooltip-text", _("what exposure correction have actually been used"), (char *)NULL); gtk_box_pack_start(GTK_BOX(hbox1), GTK_WIDGET(g->deflicker_used_EC), FALSE, FALSE, 0); dt_pthread_mutex_lock(&g->lock); g->deflicker_computed_exposure = NAN; dt_pthread_mutex_unlock(&g->lock); gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(hbox1), FALSE, FALSE, 0); gtk_widget_show_all(vbox_deflicker); gtk_stack_add_named(GTK_STACK(g->mode_stack), vbox_deflicker, "deflicker"); g_signal_connect(G_OBJECT(g->mode), "value-changed", G_CALLBACK(mode_callback), self); g_signal_connect(G_OBJECT(g->black), "value-changed", G_CALLBACK(black_callback), self); g_signal_connect(G_OBJECT(g->exposure), "value-changed", G_CALLBACK(exposure_callback), self); g_signal_connect(G_OBJECT(g->autoexpp), "value-changed", G_CALLBACK(autoexpp_callback), self); g_signal_connect(G_OBJECT(g->autoexp), "toggled", G_CALLBACK(autoexp_callback), self); g_signal_connect(G_OBJECT(g->deflicker_percentile), "value-changed", G_CALLBACK(deflicker_params_callback), self); g_signal_connect(G_OBJECT(g->deflicker_target_level), "value-changed", G_CALLBACK(deflicker_params_callback), self); g_signal_connect(G_OBJECT(g->deflicker_histogram_source), "value-changed", G_CALLBACK(deflicker_histogram_source_callback), self); g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(draw), self); }
/** 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 Boolean3OptionView::_createItem() { myCheckBox = GTK_CHECK_BUTTON(gtk_check_button_new_with_mnemonic(gtkString(name()).c_str())); setState(((ZLBoolean3OptionEntry&)*myOption).initialState()); g_signal_connect(GTK_WIDGET(myCheckBox), "released", G_CALLBACK(_onReleased), this); myHolder.attachWidget(*this, GTK_WIDGET(myCheckBox)); }
void BooleanOptionView::_createItem() { myCheckBox = GTK_CHECK_BUTTON(gtk_check_button_new_with_mnemonic(gtkString(name()).c_str())); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(myCheckBox), ((ZLBooleanOptionEntry&)*myOption).initialState()); g_signal_connect(GTK_WIDGET(myCheckBox), "toggled", G_CALLBACK(_onValueChanged), this); myHolder.attachWidget(*this, GTK_WIDGET(myCheckBox)); }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_exposure_gui_data_t)); dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data; dt_iop_exposure_params_t *p = (dt_iop_exposure_params_t *)self->params; /* register hooks with current dev so that histogram can interact with this module. */ darktable.develop->proxy.exposure.module = self; darktable.develop->proxy.exposure.set_white = dt_iop_exposure_set_white; darktable.develop->proxy.exposure.get_white = dt_iop_exposure_get_white; darktable.develop->proxy.exposure.set_black = dt_iop_exposure_set_black; darktable.develop->proxy.exposure.get_black = dt_iop_exposure_get_black; self->request_color_pick = 0; self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE)); g->black = dt_bauhaus_slider_new_with_range(self, -0.1, 0.1, .001, p->black, 4); g_object_set(G_OBJECT(g->black), "tooltip-text", _("adjust the black level"), (char *)NULL); dt_bauhaus_slider_set_format(g->black,"%.4f"); dt_bauhaus_widget_set_label(g->black, NULL, _("black")); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->black), TRUE, TRUE, 0); g->exposure = dt_bauhaus_slider_new_with_range(self, -3.0, 3.0, .02, p->exposure, 3); g_object_set(G_OBJECT(g->exposure), "tooltip-text", _("adjust the exposure correction"), (char *)NULL); dt_bauhaus_slider_set_format(g->exposure,"%.2fEV"); dt_bauhaus_widget_set_label(g->exposure, NULL, _("exposure")); dt_bauhaus_slider_enable_soft_boundaries(g->exposure, -18.0, 18.0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->exposure), TRUE, TRUE, 0); g->autoexp = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("auto"))); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoexp), FALSE); g->autoexpp = dt_bauhaus_slider_new_with_range(self, 0.0, 0.2, .001, 0.01,3); g_object_set(G_OBJECT(g->autoexpp), "tooltip-text", _("percentage of bright values clipped out"), (char *)NULL); gtk_widget_set_sensitive(GTK_WIDGET(g->autoexpp), TRUE); GtkHBox *hbox = GTK_HBOX(gtk_hbox_new(FALSE, 0)); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexp), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexpp), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0); g->deflicker = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("deflicker"))); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->deflicker), p->deflicker); g->deflicker_percentile = dt_bauhaus_slider_new_with_range(self, 0, 100, .01, p->deflicker_percentile, 3); g_object_set(G_OBJECT(g->deflicker_percentile), "tooltip-text", _("percentile"), (char *)NULL); dt_bauhaus_slider_set_format(g->deflicker_percentile,"%.2f%%"); dt_bauhaus_widget_set_label(g->deflicker_percentile, NULL, _("percentile")); gtk_widget_set_sensitive(GTK_WIDGET(g->deflicker_percentile), p->deflicker); g->deflicker_level = dt_bauhaus_slider_new_with_range(self, -18.0, 18.0, .01, p->deflicker_level, 3); g_object_set(G_OBJECT(g->deflicker_level), "tooltip-text", _("target level"), (char *)NULL); dt_bauhaus_slider_set_format(g->deflicker_level,"%.2fEV"); dt_bauhaus_widget_set_label(g->deflicker_level, NULL, _("target level")); gtk_widget_set_sensitive(GTK_WIDGET(g->deflicker_level), p->deflicker); GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE)); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->deflicker_percentile), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->deflicker_level), TRUE, TRUE, 0); GtkHBox *hbox2 = GTK_HBOX(gtk_hbox_new(FALSE, 0)); gtk_box_pack_start(GTK_BOX(hbox2), GTK_WIDGET(g->deflicker), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox2), GTK_WIDGET(vbox), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox2), TRUE, TRUE, 0); darktable.gui->reset = 1; self->gui_update(self); darktable.gui->reset = 0; g_signal_connect (G_OBJECT (g->black), "value-changed", G_CALLBACK (black_callback), self); g_signal_connect (G_OBJECT (g->exposure), "value-changed", G_CALLBACK (exposure_callback), self); g_signal_connect (G_OBJECT (g->autoexpp), "value-changed", G_CALLBACK (autoexpp_callback), self); g_signal_connect (G_OBJECT (g->autoexp), "toggled", G_CALLBACK (autoexp_callback), self); g_signal_connect (G_OBJECT (g->deflicker), "toggled", G_CALLBACK (deflicker_callback), self); g_signal_connect (G_OBJECT (g->deflicker_percentile), "value-changed", G_CALLBACK (deflicker_params_callback), self); g_signal_connect (G_OBJECT (g->deflicker_level), "value-changed", G_CALLBACK (deflicker_params_callback), self); g_signal_connect (G_OBJECT(self->widget), "expose-event", G_CALLBACK(expose), self); }