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);
}
