void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_rlce_gui_data_t));
dt_iop_rlce_gui_data_t *g = (dt_iop_rlce_gui_data_t *)self->gui_data;
dt_iop_rlce_params_t *p = (dt_iop_rlce_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox1 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
g->label1 = dtgtk_reset_label_new(_("radius"), self, &p->radius, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), g->label1, TRUE, TRUE, 0);
g->label2 = dtgtk_reset_label_new(_("amount"), self, &p->slope, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), g->label2, TRUE, TRUE, 0);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 256.0, 1.0, p->radius, 0));
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,1.0, 3.0, 0.05, p->slope, 2));
//dtgtk_slider_set_format_type(g->scale2,DARKTABLE_SLIDER_FORMAT_PERCENT);
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("size of features to preserve"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("strength of the effect"), (char *)NULL);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (radius_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (slope_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
// init the slider (more sophisticated layouts are possible with gtk tables and boxes):
self->gui_data = malloc(sizeof(dt_iop_anlfyeni_gui_data_t));
dt_iop_anlfyeni_gui_data_t *g = (dt_iop_anlfyeni_gui_data_t *)self->gui_data;
dt_iop_anlfyeni_params_t *p = (dt_iop_anlfyeni_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox), TRUE, TRUE, 5);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.001, 0.07, 0.001, p->alpha, 3));
g_object_set (GTK_OBJECT(g->scale1), "tooltip-text", _("sensitivity of edge detection"), (char *)NULL);
dtgtk_slider_set_label(g->scale1,_("sensitivity"));
// dtgtk_slider_set_accel(g->scale1,darktable.control->accels_darkroom,"<Darktable>/darkroom/modules/local_contrast_2/sensitivity");
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 6.0000, 0.010, p->scale, 3));
g_object_set (GTK_OBJECT(g->scale2), "tooltip-text", _("spatial extent of the effect around edges"), (char *)NULL);
dtgtk_slider_set_label(g->scale2,_("scale"));
// dtgtk_slider_set_accel(g->scale2,darktable.control->accels_darkroom,"<Darktable>/darkroom/modules/local_contrast_2/scale");
g->scale3 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 10.0000, 0.001, p->strength, 3));
g_object_set (GTK_OBJECT(g->scale3), "tooltip-text", _("strength of the local contrast"), (char *)NULL);
dtgtk_slider_set_label(g->scale3,_("strength"));
// dtgtk_slider_set_accel(g->scale3,darktable.control->accels_darkroom,"<Darktable>/darkroom/modules/local_contrast_2/strength");
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale3), TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (alpha_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (scale_callback), self);
g_signal_connect (G_OBJECT (g->scale3), "value-changed",
G_CALLBACK (strength_callback), self);
}
void Dialog::addRadioIcons(GtkWidget* vbox, const char* name, StringArrayRange icons, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
{
GtkWidget* table = gtk_table_new (2, static_cast<guint>(icons.last - icons.first), FALSE);
gtk_widget_show (table);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
GSList* group = 0;
GtkWidget* radio = 0;
for(StringArrayRange::Iterator icon = icons.first; icon != icons.last; ++icon)
{
guint pos = static_cast<guint>(icon - icons.first);
GtkImage* image = new_local_image(*icon);
gtk_widget_show(GTK_WIDGET(image));
gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(image), pos, pos+1, 0, 1,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
radio = gtk_radio_button_new(group);
gtk_widget_show (radio);
gtk_table_attach (GTK_TABLE (table), radio, pos, pos+1, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
}
AddIntRadioData(*GTK_RADIO_BUTTON(radio), importViewer, exportViewer);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(DialogRow_new(name, table)));
}
GtkWidget* Dialog::addFloatEntry(GtkWidget* vbox, const char* name, const FloatImportCallback& importViewer, const FloatExportCallback& exportViewer)
{
DialogEntryRow row(DialogEntryRow_new(name));
AddFloatEntryData(*row.m_entry, importViewer, exportViewer);
DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
return row.m_row;
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_grain_gui_data_t));
dt_iop_grain_gui_data_t *g = (dt_iop_grain_gui_data_t *)self->gui_data;
dt_iop_grain_params_t *p = (dt_iop_grain_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox), TRUE, TRUE, 5);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 100.0, 3200.0, 20.0, p->scale*53.3, 0));
dtgtk_slider_set_snap(g->scale1, 20);
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 0.0, 100.0, 1.0, p->strength, 2));
dtgtk_slider_set_format_type(g->scale2,DARKTABLE_SLIDER_FORMAT_PERCENT);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the grain size (~iso of the film)"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("the strength of applied grain"), (char *)NULL);
dtgtk_slider_set_label(g->scale1,_("coarseness"));
dtgtk_slider_set_unit(g->scale1,"ISO");
dtgtk_slider_set_label(g->scale2,_("strength"));
dtgtk_slider_set_unit(g->scale2,"%");
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (scale_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (strength_callback), self);
}
void gui_init (dt_iop_module_t *self)
{
// init the slider (more sophisticated layouts are possible with gtk tables and boxes):
self->gui_data = malloc(sizeof(dt_iop_colorcontrast_gui_data_t));
dt_iop_colorcontrast_gui_data_t *g = (dt_iop_colorcontrast_gui_data_t *)self->gui_data;
dt_iop_colorcontrast_params_t *p = (dt_iop_colorcontrast_params_t *)self->params;
g->a_scale = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 0.0, 5.0, 0.01, p->a_steepness, 2));
dtgtk_slider_set_label(g->a_scale,_("green vs magenta"));
g->b_scale = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 0.0, 5.0, 0.01, p->b_steepness, 2));
dtgtk_slider_set_label(g->b_scale,_("blue vs yellow"));
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->a_scale), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->b_scale), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->a_scale), "tooltip-text",
_("steepness of the a* curve in Lab"), (char *)NULL);
g_object_set(G_OBJECT(g->b_scale), "tooltip-text",
_("steepness of the b* curve in Lab"), (char *)NULL);
g_signal_connect(G_OBJECT(g->a_scale), "value-changed",
G_CALLBACK(a_slider_callback), self);
g_signal_connect(G_OBJECT(g->b_scale), "value-changed",
G_CALLBACK(b_slider_callback), self);
}
GtkVBox* create_dialog_vbox(int spacing, int border)
{
GtkVBox* vbox = GTK_VBOX(gtk_vbox_new(FALSE, spacing));
gtk_widget_show(GTK_WIDGET(vbox));
gtk_container_set_border_width(GTK_CONTAINER(vbox), border);
return vbox;
}
/* greebo: This adds a horizontal slider and connects it to the value of the given registryKey
*/
void Dialog::addSlider (GtkWidget* vbox, const std::string& name, const std::string& registryKey,
gboolean draw_value, double value, double lower, double upper,
double step_increment, double page_increment, double page_size)
{
// Create a new adjustment with the boundaries <lower> and <upper> and all the increments
GtkObject* adj = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
// Connect the registry key to this adjustment
_registryConnector.connectGtkObject(adj, registryKey);
// scale
GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 1.0, 0.0);
gtk_widget_show(alignment);
GtkWidget* scale = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_LEFT);
gtk_widget_show(scale);
gtk_container_add(GTK_CONTAINER(alignment), scale);
gtk_scale_set_draw_value(GTK_SCALE (scale), draw_value);
int digits = (step_increment < 1.0f) ? 2 : 0;
gtk_scale_set_digits(GTK_SCALE (scale), digits);
GtkTable* row = DialogRow_new(name, alignment);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
}
void Dialog::addCombo (GtkWidget* vbox, const std::string& name, const std::string& registryKey,
const ComboBoxValueList& valueList)
{
GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
gtk_widget_show(alignment);
{
// Create a new combo box
GtkWidget* combo = gtk_combo_box_new_text();
// Add all the string values to the combo box
for (ComboBoxValueList::const_iterator i = valueList.begin(); i != valueList.end(); i++) {
// Add the current string value to the combo box
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), i->c_str());
}
// Connect the registry key to the newly created combo box
_registryConnector.connectGtkObject(GTK_OBJECT(combo), registryKey);
// Add it to the container and make it visible
gtk_widget_show(combo);
gtk_container_add(GTK_CONTAINER(alignment), combo);
}
// Add the widget to the dialog row
GtkTable* row = DialogRow_new(name, alignment);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
}
static void nyth_tcu_dcu_dialog_init(NythSensorDcuDialog *tcu_dcu_dialog) {
NythSensorDcuDialogPrivate *priv = NYTH_TCU_DCU_DIALOG_GET_PRIVATE(tcu_dcu_dialog);
GtkVBox *content_area;
tcu_dcu_dialog->priv = priv;
gtk_dialog_add_buttons(GTK_DIALOG(tcu_dcu_dialog),
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_modal(GTK_WINDOW(tcu_dcu_dialog), TRUE);
gtk_window_set_destroy_with_parent(GTK_WINDOW(tcu_dcu_dialog), TRUE);
gtk_window_set_title(GTK_WINDOW(tcu_dcu_dialog), _("TCU/DCU"));
content_area = GTK_VBOX(gtk_dialog_get_content_area(GTK_DIALOG(tcu_dcu_dialog)));
priv->tcu = NYTH_TCU_FRAME(nyth_tcu_frame_new());
priv->dcu = NYTH_DCU_FRAME(nyth_dcu_frame_new());
g_signal_connect(G_OBJECT(priv->tcu), "changed", G_CALLBACK(tcu_changed_cb), tcu_dcu_dialog);
g_signal_connect(G_OBJECT(priv->dcu), "changed", G_CALLBACK(dcu_changed_cb), tcu_dcu_dialog);
gtk_box_pack_start(GTK_BOX(content_area), GTK_WIDGET(priv->tcu), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(content_area), GTK_WIDGET(priv->dcu), FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(content_area));
}
GtkWidget* Dialog::addSpinner(GtkWidget* vbox, const char* name, double value, double lower, double upper, const FloatImportCallback& importViewer, const FloatExportCallback& exportViewer)
{
DialogSpinnerRow row(DialogSpinnerRow_new(name, value, lower, upper, 10));
AddFloatSpinnerData(*row.m_spin, importViewer, exportViewer);
DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
return row.m_row;
}
GtkWidget* Dialog::addCheckBox(GtkWidget* vbox, const char* name, const char* flag, const BoolImportCallback& importViewer, const BoolExportCallback& exportViewer)
{
GtkWidget* check = gtk_check_button_new_with_label(flag);
gtk_widget_show(check);
AddBoolToggleData(*GTK_TOGGLE_BUTTON(check), importViewer, exportViewer);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(DialogRow_new(name, check)));
return check;
}
// greebo: add an entry box connected to the given registryKey
GtkWidget* Dialog::addEntry (GtkWidget* vbox, const std::string& name, const std::string& registryKey)
{
// Create a new row containing an input field
DialogEntryRow row(DialogEntryRow_new(name));
// Connect the registry key to the newly created input field
_registryConnector.connectGtkObject(GTK_OBJECT(row.m_entry), registryKey);
DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
return row.m_row;
}
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));
}
static void ryosconfig_layer_illumination_dialog_init(RyosconfigLayerIlluminationDialog *layer_illumination_dialog) {
RyosconfigLayerIlluminationDialogPrivate *priv = RYOSCONFIG_LAYER_ILLUMINATION_DIALOG_GET_PRIVATE(layer_illumination_dialog);
GtkVBox *content_area;
GtkWidget *info_frame;
GtkWidget *info_text;
GtkWidget *effect_frame;
GtkWidget *preset_frame;
GtkTable *table;
layer_illumination_dialog->priv = priv;
priv->light_layer = g_malloc0(sizeof(RyosLightLayer));
priv->periodic_blink_state = FALSE;
content_area = GTK_VBOX(gtk_dialog_get_content_area(GTK_DIALOG(layer_illumination_dialog)));
info_frame = gtk_frame_new(_("Info"));
info_text = gtk_label_new(
_("Press the keys you want to toggle.\n"
"The keyboard reflects the settings, except the thumbster keys.\n"
"Remapping and special keys are not supported."));
gtk_container_add(GTK_CONTAINER(info_frame), GTK_WIDGET(info_text));
effect_frame = gtk_frame_new(_("Key effect"));
priv->blink_button = GTK_TOGGLE_BUTTON(gtk_check_button_new_with_label(_("Blinking")));
gtk_container_add(GTK_CONTAINER(effect_frame), GTK_WIDGET(priv->blink_button));
preset_frame = gtk_frame_new(_("Presets"));
table = GTK_TABLE(gtk_table_new(1, 1, TRUE));
add_array_button(layer_illumination_dialog, table, _("WASD"), preset_wasd, 0, 0);
add_array_button(layer_illumination_dialog, table, _("QWER"), preset_qwer, 0, 1);
add_array_button(layer_illumination_dialog, table, _("Arrows"), preset_arrows, 0, 2);
add_array_button(layer_illumination_dialog, table, _("F keys"), preset_f_keys, 1, 0);
add_array_button(layer_illumination_dialog, table, _("M keys"), preset_m_keys, 1, 1);
add_array_button(layer_illumination_dialog, table, _("T keys"), preset_t_keys, 1, 2);
add_array_button(layer_illumination_dialog, table, _("Main Block"), preset_main_keys, 2, 0);
add_array_button(layer_illumination_dialog, table, _("Numpad"), preset_numpad, 2, 1);
add_array_button(layer_illumination_dialog, table, _("All keys"), preset_all_keys, 2, 2);
gtk_container_add(GTK_CONTAINER(preset_frame), GTK_WIDGET(table));
gtk_box_pack_start(GTK_BOX(content_area), info_frame, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content_area), effect_frame, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content_area), preset_frame, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(layer_illumination_dialog), "key-press-event", G_CALLBACK(key_press_event_cb), NULL);
gtk_widget_show_all(GTK_WIDGET(content_area));
}
static void ryostklconfig_configuration_dialog_init(RyostklconfigConfigurationDialog *ryostklconfig_configuration_dialog) {
RyostklconfigConfigurationDialogPrivate *priv = RYOSTKLCONFIG_CONFIGURATION_DIALOG_GET_PRIVATE(ryostklconfig_configuration_dialog);
GtkVBox *content_area;
ryostklconfig_configuration_dialog->priv = priv;
content_area = GTK_VBOX(gtk_dialog_get_content_area(GTK_DIALOG(ryostklconfig_configuration_dialog)));
gtk_box_pack_start(GTK_BOX(content_area), general_frame_new(ryostklconfig_configuration_dialog), TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(content_area));
}
/* greebo: This adds a checkbox to the given VBox and connects an XMLRegistry value to it.
* The actual data is "imported" and "exported" via those templates.
*/
GtkWidget* Dialog::addCheckBox(GtkWidget* vbox, const std::string& name, const std::string& flag, const std::string& registryKey)
{
// Create a new checkbox with the given caption and display it
GtkWidget* check = gtk_check_button_new_with_label(flag.c_str());
gtk_widget_show(check);
// Connect the registry key to this toggle button
_registryConnector.connectGtkObject(GTK_OBJECT(check), registryKey);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(DialogRow_new(name, check)));
return check;
}
GtkWidget* Dialog::addPathEntry(GtkWidget* vbox, const char* name, bool browse_directory, const StringImportCallback& importViewer, const StringExportCallback& exportViewer)
{
PathEntry pathEntry = PathEntry_new();
g_signal_connect(G_OBJECT(pathEntry.m_button), "clicked", G_CALLBACK(browse_directory ? button_clicked_entry_browse_directory : button_clicked_entry_browse_file), pathEntry.m_entry);
AddTextEntryData(*GTK_ENTRY(pathEntry.m_entry), importViewer, exportViewer);
GtkTable* row = DialogRow_new(name, GTK_WIDGET(pathEntry.m_frame));
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
return GTK_WIDGET(row);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_channelmixer_gui_data_t));
dt_iop_channelmixer_gui_data_t *g = (dt_iop_channelmixer_gui_data_t *)self->gui_data;
dt_iop_channelmixer_params_t *p = (dt_iop_channelmixer_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->dtlabel1 = DTGTK_LABEL( dtgtk_label_new(_("output channel"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT) );
g->combo1 = GTK_COMBO_BOX( gtk_combo_box_new_text() );
gtk_combo_box_append_text(g->combo1,_("hue"));
gtk_combo_box_append_text(g->combo1,_("saturation"));
gtk_combo_box_append_text(g->combo1,_("lightness"));
gtk_combo_box_append_text(g->combo1,_("red"));
gtk_combo_box_append_text(g->combo1,_("green"));
gtk_combo_box_append_text(g->combo1,_("blue"));
gtk_combo_box_append_text(g->combo1,_("gray"));
gtk_combo_box_set_active(g->combo1, CHANNEL_RED );
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->dtlabel1), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->combo1), TRUE, TRUE, 5);
g->dtlabel2 = DTGTK_LABEL( dtgtk_label_new(_("source channels"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT) );
GtkBox *hbox = GTK_BOX( gtk_hbox_new(FALSE, 0));
g->vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->dtlabel2), TRUE, TRUE, 5);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,-2.0, 2.0, 0.005, p->red[CHANNEL_RED] , 3));
g_object_set (GTK_OBJECT(g->scale1), "tooltip-text", _("amount of red channel in the output channel"), (char *)NULL);
dtgtk_slider_set_label(g->scale1,_("red"));
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,-2.0, 2.0, 0.005, p->green[CHANNEL_RED] , 3));
g_object_set (GTK_OBJECT(g->scale2), "tooltip-text", _("amount of green channel in the output channel"), (char *)NULL);
dtgtk_slider_set_label(g->scale2,_("green"));
g->scale3 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,-2.0, 2.0, 0.005, p->blue[CHANNEL_RED] , 3));
g_object_set (GTK_OBJECT(g->scale3), "tooltip-text", _("amount of blue channel in the output channel"), (char *)NULL);
dtgtk_slider_set_label(g->scale3,_("blue"));
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale3), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (red_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (green_callback), self);
g_signal_connect (G_OBJECT (g->scale3), "value-changed",
G_CALLBACK (blue_callback), self);
g_signal_connect (G_OBJECT (g->combo1), "changed",
G_CALLBACK (output_callback), self);
}
void Dialog::addRadio(GtkWidget* vbox, const char* name, StringArrayRange names, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
{
GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
gtk_widget_show(alignment);
{
RadioHBox radioBox = RadioHBox_new(names);
gtk_container_add(GTK_CONTAINER(alignment), GTK_WIDGET(radioBox.m_hbox));
AddIntRadioData(*GTK_RADIO_BUTTON(radioBox.m_radio), importViewer, exportViewer);
}
GtkTable* row = DialogRow_new(name, alignment);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
}
static void pyraconfig_configuration_dialog_init(PyraconfigConfigurationDialog *pyraconfig_configuration_dialog) {
PyraconfigConfigurationDialogPrivate *priv = PYRACONFIG_CONFIGURATION_DIALOG_GET_PRIVATE(pyraconfig_configuration_dialog);
GtkVBox *content_area;
pyraconfig_configuration_dialog->priv = priv;
content_area = GTK_VBOX(gtk_dialog_get_content_area(GTK_DIALOG(pyraconfig_configuration_dialog)));
gtk_box_pack_start(GTK_BOX(content_area), notification_frame_new(pyraconfig_configuration_dialog), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content_area), general_frame_new(pyraconfig_configuration_dialog), TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(content_area));
}
static void konextdopticalconfig_configuration_dialog_init(KonextdopticalconfigConfigurationDialog *konextdopticalconfig_configuration_dialog) {
KonextdopticalconfigConfigurationDialogPrivate *priv = KONEXTDOPTICALCONFIG_CONFIGURATION_DIALOG_GET_PRIVATE(konextdopticalconfig_configuration_dialog);
GtkVBox *content_area;
konextdopticalconfig_configuration_dialog->priv = priv;
content_area = GTK_VBOX(gtk_dialog_get_content_area(GTK_DIALOG(konextdopticalconfig_configuration_dialog)));
gtk_box_pack_start(GTK_BOX(content_area), notification_frame_new(konextdopticalconfig_configuration_dialog), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content_area), general_frame_new(konextdopticalconfig_configuration_dialog), TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(content_area));
}
// greebo: Adds a PathEntry to choose files or directories (depending on the given boolean)
GtkWidget* Dialog::addPathEntry (GtkWidget* vbox, const std::string& name, const std::string& registryKey,
bool browseDirectories)
{
PathEntry pathEntry = PathEntry_new();
g_signal_connect(G_OBJECT(pathEntry.m_button), "clicked", G_CALLBACK(browseDirectories ? button_clicked_entry_browse_directory : button_clicked_entry_browse_file), pathEntry.m_entry);
// Connect the registry key to the newly created input field
_registryConnector.connectGtkObject(GTK_OBJECT(pathEntry.m_entry), registryKey);
GtkTable* row = DialogRow_new(name, GTK_WIDGET(pathEntry.m_frame));
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
return GTK_WIDGET(row);
}
static void roccat_timer_dialog_init(RoccatTimerDialog *timer_dialog) {
RoccatTimerDialogPrivate *priv = ROCCAT_TIMER_DIALOG_GET_PRIVATE(timer_dialog);
GtkVBox *content_area;
timer_dialog->priv = priv;
content_area = GTK_VBOX(gtk_dialog_get_content_area(GTK_DIALOG(timer_dialog)));
priv->combo_box = GTK_COMBO_BOX(roccat_timer_combo_box_new());
g_signal_connect(G_OBJECT(priv->combo_box), "changed", G_CALLBACK(changed_cb), timer_dialog);
gtk_box_pack_start(GTK_BOX(content_area), GTK_WIDGET(priv->combo_box), FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(content_area));
}
GtkWidget* Dialog::addSpinner (GtkWidget* vbox, const std::string& name, const std::string& registryKey, double lower,
double upper, int fraction)
{
// Load the initial value (maybe unnecessary, as the value is loaded upon dialog show)
float value = GlobalRegistry().getFloat(registryKey);
// Create a new row containing an input field
DialogSpinnerRow row(DialogSpinnerRow_new(name.c_str(), value, lower, upper, fraction));
// Connect the registry key to the newly created input field
_registryConnector.connectGtkObject(GTK_OBJECT(row.m_spin), registryKey);
DialogVBox_packRow(GTK_VBOX(vbox), row.m_row);
return row.m_row;
}
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 roccat_timer_editor_dialog_init(RoccatTimerEditorDialog *timer_editor_dialog) {
RoccatTimerEditorDialogPrivate *priv = ROCCAT_TIMER_EDITOR_DIALOG_GET_PRIVATE(timer_editor_dialog);
GtkVBox *content_area;
RoccatTimerListStore *store;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *scrolled_window;
GtkWidget *hbox;
GtkWidget *add_button;
GtkWidget *remove_button;
timer_editor_dialog->priv = priv;
content_area = GTK_VBOX(gtk_dialog_get_content_area(GTK_DIALOG(timer_editor_dialog)));
frame = gtk_frame_new(_("Timers"));
vbox = gtk_vbox_new(FALSE, 0);
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
hbox = gtk_hbox_new(FALSE, 0);
add_button = gtk_button_new_with_label(_("Add"));
remove_button = gtk_button_new_with_label(_("Remove"));
store = roccat_timer_list_store_new();
priv->tree_view = ROCCAT_TIMER_TREE_VIEW(roccat_timer_tree_view_new(store));
g_object_unref(store);
gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(priv->tree_view));
gtk_box_pack_start(GTK_BOX(hbox), add_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), remove_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
gtk_box_pack_start(GTK_BOX(content_area), roccat_timer_editor_dialog_menu_bar_new(timer_editor_dialog), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(content_area), frame, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(add_button), "clicked", G_CALLBACK(add_cb), priv->tree_view);
g_signal_connect(G_OBJECT(remove_button), "clicked", G_CALLBACK(remove_cb), priv->tree_view);
gtk_widget_show_all(GTK_WIDGET(content_area));
}
void Dialog::addCombo(GtkWidget* vbox, const char* name, StringArrayRange values, const IntImportCallback& importViewer, const IntExportCallback& exportViewer)
{
GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
gtk_widget_show(alignment);
{
GtkWidget* combo = gtk_combo_box_new_text();
for(StringArrayRange::Iterator i = values.first; i != values.last; ++i)
{
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), *i);
}
AddIntComboData(*GTK_COMBO_BOX(combo), importViewer, exportViewer);
gtk_widget_show (combo);
gtk_container_add(GTK_CONTAINER(alignment), combo);
}
GtkTable* row = DialogRow_new(name, alignment);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
}
void Dialog::addSlider(GtkWidget* vbox, const char* name, int& data, gboolean draw_value, const char* low, const char* high, double value, double lower, double upper, double step_increment, double page_increment)
{
#if 0
if(draw_value == FALSE)
{
GtkWidget* hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox2), FALSE, FALSE, 0);
{
GtkWidget* label = gtk_label_new (low);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
}
{
GtkWidget* label = gtk_label_new (high);
gtk_widget_show (label);
gtk_box_pack_end (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
}
}
#endif
// adjustment
GtkObject* adj = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, 0);
AddIntAdjustmentData(*GTK_ADJUSTMENT(adj), IntImportCaller(data), IntExportCaller(data));
// scale
GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 1.0, 0.0);
gtk_widget_show(alignment);
GtkWidget* scale = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_LEFT);
gtk_widget_show(scale);
gtk_container_add(GTK_CONTAINER(alignment), scale);
gtk_scale_set_draw_value(GTK_SCALE (scale), draw_value);
gtk_scale_set_digits(GTK_SCALE (scale), 0);
GtkTable* row = DialogRow_new(name, alignment);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_vibrance_gui_data_t));
dt_iop_vibrance_gui_data_t *g = (dt_iop_vibrance_gui_data_t *)self->gui_data;
dt_iop_vibrance_params_t *p = (dt_iop_vibrance_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(vbox), TRUE, TRUE, 5);
g->amount_scale = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 100.0, 1, p->amount, 0));
dtgtk_slider_set_format_type(g->amount_scale,DARKTABLE_SLIDER_FORMAT_PERCENT);
dtgtk_slider_set_label(g->amount_scale,_("vibrance"));
dtgtk_slider_set_unit(g->amount_scale,"%");
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->amount_scale), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->amount_scale), "tooltip-text", _("the amount of vibrance"), (char *)NULL);
g_signal_connect (G_OBJECT (g->amount_scale), "value-changed",
G_CALLBACK (amount_callback), self);
}
