void gui_init (dt_iop_module_t *self)
{
const int bs = 14;
self->gui_data = malloc(sizeof(dt_iop_spots_gui_data_t));
dt_iop_spots_gui_data_t *g = (dt_iop_spots_gui_data_t *)self->gui_data;
self->widget = gtk_vbox_new(FALSE, 5);
GtkWidget * hbox = gtk_hbox_new(FALSE, 5);
GtkWidget *label = gtk_label_new(_("number of strokes:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
g->label = GTK_LABEL(gtk_label_new("-1"));
g_object_set(G_OBJECT(hbox), "tooltip-text", _("click on a shape and drag on canvas.\nuse the mouse wheel to adjust size.\nright click to remove a shape."), (char *)NULL);
g->bt_path = dtgtk_togglebutton_new(dtgtk_cairo_paint_masks_path, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
g_signal_connect(G_OBJECT(g->bt_path), "button-press-event", G_CALLBACK(_add_path), self);
g_object_set(G_OBJECT(g->bt_path), "tooltip-text", _("add path"), (char *)NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_path), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->bt_path),bs,bs);
gtk_box_pack_end (GTK_BOX (hbox),g->bt_path,FALSE,FALSE,0);
g->bt_circle = dtgtk_togglebutton_new(dtgtk_cairo_paint_masks_circle, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
g_signal_connect(G_OBJECT(g->bt_circle), "button-press-event", G_CALLBACK(_add_circle), self);
g_object_set(G_OBJECT(g->bt_circle), "tooltip-text", _("add circle"), (char *)NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_circle), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->bt_circle),bs,bs);
gtk_box_pack_end (GTK_BOX (hbox),g->bt_circle,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->label), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), hbox, TRUE, TRUE, 0);
}
/** Add a new property of camera to the gui */
dt_lib_camera_property_t *_lib_property_add_new(dt_lib_camera_t * lib, const gchar *label,const gchar *propertyname)
{
if( dt_camctl_camera_property_exists(darktable.camctl,NULL,propertyname) )
{
const char *value;
if( (value=dt_camctl_camera_property_get_first_choice(darktable.camctl,NULL,propertyname)) != NULL )
{
// We got a value for property lets construct the gui for the property and add values
dt_lib_camera_property_t *prop = malloc(sizeof(dt_lib_camera_property_t));
memset(prop,0,sizeof(dt_lib_camera_property_t));
prop->name=label;
prop->property_name=propertyname;
prop->label = GTK_LABEL(gtk_label_new(label));
gtk_misc_set_alignment(GTK_MISC(prop->label ), 0.0, 0.5);
prop->values=GTK_COMBO_BOX(gtk_combo_box_new_text());
prop->osd=DTGTK_TOGGLEBUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_eye,0));
g_object_set(G_OBJECT(prop->osd), "tooltip-text", _("toggle view property in center view"), (char *)NULL);
do
{
gtk_combo_box_append_text(prop->values, g_dgettext("libgphoto2-2", value));
}
while( (value=dt_camctl_camera_property_get_next_choice(darktable.camctl,NULL,propertyname)) != NULL );
lib->gui.properties=g_list_append(lib->gui.properties,prop);
// Does dead lock!!!
g_signal_connect(G_OBJECT(prop->values), "changed", G_CALLBACK(property_changed_callback), (gpointer)prop);
return prop;
}
}
return NULL;
}
void gui_init(dt_iop_module_t *self)
{
self->gui_data = g_malloc(sizeof(dt_iop_invert_gui_data_t));
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
self->widget = gtk_hbox_new(FALSE, 5);
GtkWidget *tb;
g->label = DTGTK_RESET_LABEL(dtgtk_reset_label_new ("", self, &p->color, 3*sizeof(float)));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->label), TRUE, TRUE, 0);
g->pickerbuttons = GTK_HBOX(gtk_hbox_new(FALSE, 5));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->pickerbuttons), TRUE, TRUE, 0);
g->colorpicker = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color, CPF_IGNORE_FG_STATE|CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
gtk_widget_set_size_request(GTK_WIDGET(g->colorpicker), 75, 24);
g_signal_connect (G_OBJECT (g->colorpicker), "clicked", G_CALLBACK (colorpicker_callback), self);
gtk_box_pack_start(GTK_BOX(g->pickerbuttons), GTK_WIDGET(g->colorpicker), TRUE, TRUE, 0);
tb = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(tb), "tooltip-text", _("pick color of film material from image"), (char *)NULL);
gtk_widget_set_size_request(tb, 24, 24);
g_signal_connect(G_OBJECT(tb), "toggled", G_CALLBACK(request_pick_toggled), self);
gtk_box_pack_start(GTK_BOX(g->pickerbuttons), tb, TRUE, TRUE, 5);
g_signal_connect (G_OBJECT(self->widget), "expose-event", G_CALLBACK(expose), self);
}
GtkWidget*
dtgtk_togglebutton_new_with_label (const gchar *label, DTGTKCairoPaintIconFunc paint, gint paintflags)
{
GtkWidget *button = dtgtk_togglebutton_new(paint,paintflags);
gtk_button_set_label(GTK_BUTTON (button), label);
return button;
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_relight_gui_data_t));
dt_iop_relight_gui_data_t *g = (dt_iop_relight_gui_data_t *)self->gui_data;
dt_iop_relight_params_t *p = (dt_iop_relight_params_t *)self->params;
self->widget = gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE);
g_signal_connect (G_OBJECT (self->widget), "expose-event", G_CALLBACK (expose), self);
/* exposure */
g->scale1 = dt_bauhaus_slider_new_with_range(self,-2.0, 2.0,0.05, p->ev, 2);
dt_bauhaus_slider_set_format(g->scale1,"%.2fEV");
dt_bauhaus_widget_set_label(g->scale1,_("exposure"));
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the fill-light in EV"), (char *)NULL);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (ev_callback), self);
/* width*/
g->scale2 = dt_bauhaus_slider_new_with_range(self,2, 10, 0.5, p->width, 1);
dt_bauhaus_slider_set_format(g->scale2,"%.1f");
dt_bauhaus_widget_set_label(g->scale2,_("width"));
/* xgettext:no-c-format */
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("width of fill-light area defined in zones"), (char *)NULL);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (width_callback), self);
/* lightnessslider */
GtkBox *hbox=GTK_BOX (gtk_hbox_new (FALSE,2));
int lightness=32768;
g->gslider1=DTGTK_GRADIENT_SLIDER (dtgtk_gradient_slider_new_with_color ((GdkColor)
{
0,0,0,0
},(GdkColor)
{
0,lightness,lightness,lightness
}));
g_object_set(G_OBJECT (g->gslider1), "tooltip-text", _("select the center of fill-light"), (char *)NULL);
g_signal_connect (G_OBJECT (g->gslider1), "value-changed",
G_CALLBACK (center_callback), self);
g->tbutton1 = DTGTK_TOGGLEBUTTON (dtgtk_togglebutton_new (dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
gtk_widget_set_size_request(GTK_WIDGET(g->tbutton1),22,22);
g_signal_connect (G_OBJECT (g->tbutton1), "toggled",
G_CALLBACK (picker_callback), self);
gtk_box_pack_start (hbox,GTK_WIDGET (g->gslider1),TRUE,TRUE,0);
gtk_box_pack_start (hbox,GTK_WIDGET (g->tbutton1),FALSE,FALSE,0);
/* add controls to widget ui */
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET (g->scale1),TRUE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET (hbox), TRUE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET (g->scale2),TRUE,FALSE,0);
g_object_set(G_OBJECT(g->tbutton1), "tooltip-text", _("toggle tool for picking median lightness in image"), (char *)NULL);
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_tool_preferences_t *d = (dt_lib_tool_preferences_t *)g_malloc0(sizeof(dt_lib_tool_preferences_t));
self->data = (void *)d;
self->widget = gtk_hbox_new(FALSE,2);
/* create the grouping button */
d->grouping_button = dtgtk_togglebutton_new(dtgtk_cairo_paint_grouping, CPF_STYLE_FLAT);
gtk_widget_set_size_request(d->grouping_button, DT_PIXEL_APPLY_DPI(18), DT_PIXEL_APPLY_DPI(18));
gtk_box_pack_start(GTK_BOX(self->widget), d->grouping_button, FALSE, FALSE, 2);
if(darktable.gui->grouping)
g_object_set(G_OBJECT(d->grouping_button), "tooltip-text", _("expand grouped images"), (char *)NULL);
else
g_object_set(G_OBJECT(d->grouping_button), "tooltip-text", _("collapse grouped images"), (char *)NULL);
g_signal_connect (G_OBJECT (d->grouping_button), "clicked",
G_CALLBACK (_lib_filter_grouping_button_clicked),
NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->grouping_button), darktable.gui->grouping);
/* create the "show/hide overlays" button */
d->overlays_button = dtgtk_togglebutton_new(dtgtk_cairo_paint_overlays, CPF_STYLE_FLAT);
gtk_widget_set_size_request(d->overlays_button, DT_PIXEL_APPLY_DPI(18), DT_PIXEL_APPLY_DPI(18));
gtk_box_pack_start(GTK_BOX(self->widget), d->overlays_button, FALSE, FALSE, 2);
if(darktable.gui->show_overlays)
g_object_set(G_OBJECT(d->overlays_button), "tooltip-text", _("hide image overlays"), (char *)NULL);
else
g_object_set(G_OBJECT(d->overlays_button), "tooltip-text", _("show image overlays"), (char *)NULL);
g_signal_connect (G_OBJECT (d->overlays_button), "clicked",
G_CALLBACK (_lib_overlays_button_clicked),
NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->overlays_button), darktable.gui->show_overlays);
/* create the preference button */
d->preferences_button = dtgtk_button_new(dtgtk_cairo_paint_preferences, CPF_STYLE_FLAT);
gtk_widget_set_size_request(d->preferences_button, DT_PIXEL_APPLY_DPI(18), DT_PIXEL_APPLY_DPI(18));
gtk_box_pack_end(GTK_BOX(self->widget), d->preferences_button, FALSE, FALSE, 2);
g_object_set(G_OBJECT(d->preferences_button), "tooltip-text", _("show global preferences"),
(char *)NULL);
g_signal_connect (G_OBJECT (d->preferences_button), "clicked",
G_CALLBACK (_lib_preferences_button_clicked),
NULL);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_relight_gui_data_t));
dt_iop_relight_gui_data_t *g = (dt_iop_relight_gui_data_t *)self->gui_data;
dt_iop_relight_params_t *p = (dt_iop_relight_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(draw), self);
/* exposure */
g->scale1 = dt_bauhaus_slider_new_with_range(self, -2.0, 2.0, 0.05, p->ev, 2);
dt_bauhaus_slider_set_format(g->scale1, "%.2fEV");
dt_bauhaus_widget_set_label(g->scale1, NULL, _("exposure"));
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the fill-light in EV"), (char *)NULL);
g_signal_connect(G_OBJECT(g->scale1), "value-changed", G_CALLBACK(ev_callback), self);
/* width*/
g->scale2 = dt_bauhaus_slider_new_with_range(self, 2, 10, 0.5, p->width, 1);
dt_bauhaus_slider_set_format(g->scale2, "%.1f");
dt_bauhaus_widget_set_label(g->scale2, NULL, _("width"));
/* xgettext:no-c-format */
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("width of fill-light area defined in zones"),
(char *)NULL);
g_signal_connect(G_OBJECT(g->scale2), "value-changed", G_CALLBACK(width_callback), self);
/* lightnessslider */
GtkBox *hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2));
#define NEUTRAL_GRAY 0.5
static const GdkRGBA _gradient_L[]
= { { 0, 0, 0, 1.0 }, { NEUTRAL_GRAY, NEUTRAL_GRAY, NEUTRAL_GRAY, 1.0 } };
g->gslider1 = DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color(_gradient_L[0], _gradient_L[1]));
g_object_set(G_OBJECT(g->gslider1), "tooltip-text", _("select the center of fill-light"), (char *)NULL);
g_signal_connect(G_OBJECT(g->gslider1), "value-changed", G_CALLBACK(center_callback), self);
g->tbutton1 = DTGTK_TOGGLEBUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
gtk_widget_set_size_request(GTK_WIDGET(g->tbutton1), DT_PIXEL_APPLY_DPI(22), DT_PIXEL_APPLY_DPI(22));
g_signal_connect(G_OBJECT(g->tbutton1), "toggled", G_CALLBACK(picker_callback), self);
gtk_box_pack_start(hbox, GTK_WIDGET(g->gslider1), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(g->tbutton1), FALSE, FALSE, 0);
/* add controls to widget ui */
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale1), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale2), TRUE, FALSE, 0);
g_object_set(G_OBJECT(g->tbutton1), "tooltip-text", _("toggle tool for picking median lightness in image"),
(char *)NULL);
}
void gui_update(dt_iop_module_t *self)
{
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
gtk_widget_set_visible(GTK_WIDGET(g->pickerbuttons), TRUE);
dtgtk_reset_label_set_text(g->label, _("color of film material"));
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(g->colorpicker), &color);
}
void gui_init(dt_iop_module_t *self)
{
self->gui_data = g_malloc0(sizeof(dt_iop_invert_gui_data_t));
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
g->label = DTGTK_RESET_LABEL(dtgtk_reset_label_new("", self, &p->color, 3 * sizeof(float)));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->label), TRUE, TRUE, 0);
g->pickerbuttons = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->pickerbuttons), TRUE, TRUE, 0);
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
g->colorpicker = gtk_color_button_new_with_rgba(&color);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpicker), DT_PIXEL_APPLY_DPI(75), DT_PIXEL_APPLY_DPI(24));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpicker), FALSE);
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpicker), _("select color of film material"));
g_signal_connect(G_OBJECT(g->colorpicker), "color-set", G_CALLBACK(colorpicker_callback), self);
gtk_box_pack_start(GTK_BOX(g->pickerbuttons), GTK_WIDGET(g->colorpicker), TRUE, TRUE, 0);
g->picker = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(g->picker), "tooltip-text", _("pick color of film material from image"), (char *)NULL);
gtk_widget_set_size_request(g->picker, DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
g_signal_connect(G_OBJECT(g->picker), "toggled", G_CALLBACK(request_pick_toggled), self);
gtk_box_pack_start(GTK_BOX(g->pickerbuttons), g->picker, TRUE, TRUE, 5);
g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(draw), self);
}
void gui_cleanup(dt_iop_module_t *self)
{
g_free(self->gui_data);
self->gui_data = NULL;
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_monochrome_gui_data_t));
dt_iop_monochrome_gui_data_t *g = (dt_iop_monochrome_gui_data_t *)self->gui_data;
g->dragging = 0;
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
dt_gui_add_help_link(self->widget, dt_get_help_url(self->op));
g->area = GTK_DRAWING_AREA(dtgtk_drawing_area_new_with_aspect_ratio(1.0));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->area), TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(GTK_WIDGET(g->area), _("drag and scroll mouse wheel to adjust the virtual color filter"));
gtk_widget_add_events(GTK_WIDGET(g->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_LEAVE_NOTIFY_MASK | darktable.gui->scroll_mask);
g_signal_connect(G_OBJECT(g->area), "draw", G_CALLBACK(dt_iop_monochrome_draw), self);
g_signal_connect(G_OBJECT(g->area), "button-press-event", G_CALLBACK(dt_iop_monochrome_button_press), self);
g_signal_connect(G_OBJECT(g->area), "button-release-event", G_CALLBACK(dt_iop_monochrome_button_release),
self);
g_signal_connect(G_OBJECT(g->area), "motion-notify-event", G_CALLBACK(dt_iop_monochrome_motion_notify),
self);
g_signal_connect(G_OBJECT(g->area), "leave-notify-event", G_CALLBACK(dt_iop_monochrome_leave_notify), self);
g_signal_connect(G_OBJECT(g->area), "scroll-event", G_CALLBACK(dt_iop_monochrome_scrolled), self);
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_BAUHAUS_SPACE);
g->highlights = dt_bauhaus_slider_new_with_range(self, 0.0, 1.0, 0.01, 0.0, 2);
gtk_widget_set_tooltip_text(g->highlights, _("how much to keep highlights"));
dt_bauhaus_widget_set_label(g->highlights, NULL, _("highlights"));
gtk_box_pack_start(GTK_BOX(box), g->highlights, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(g->highlights), "value-changed", G_CALLBACK(highlights_callback), self);
g->colorpicker = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpicker), DT_PIXEL_APPLY_DPI(14), DT_PIXEL_APPLY_DPI(14));
gtk_box_pack_end(GTK_BOX(box), GTK_WIDGET(g->colorpicker), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(g->colorpicker), "toggled", G_CALLBACK(picker_callback), self);
gtk_box_pack_end(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0);
cmsHPROFILE hsRGB = dt_colorspaces_get_profile(DT_COLORSPACE_SRGB, "", DT_PROFILE_DIRECTION_IN)->profile;
cmsHPROFILE hLab = dt_colorspaces_get_profile(DT_COLORSPACE_LAB, "", DT_PROFILE_DIRECTION_ANY)->profile;
g->xform = cmsCreateTransform(hLab, TYPE_Lab_DBL, hsRGB, TYPE_RGB_DBL, INTENT_PERCEPTUAL,
0); // cmsFLAGS_NOTPRECALC);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_overexposed_gui_data_t));
dt_iop_overexposed_gui_data_t *g = (dt_iop_overexposed_gui_data_t *)self->gui_data;
dt_iop_overexposed_params_t *p = (dt_iop_overexposed_params_t *)self->params;
// g->mask = NULL;
self->widget =gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE);
/* lower */
g->lower = dt_bauhaus_slider_new_with_range(self,0.0, 100.0, 0.1, p->lower, 2);
dt_bauhaus_slider_set_format(g->lower,"%.0f%%");
dt_bauhaus_widget_set_label(g->lower,_("lower threshold"));
g_object_set(G_OBJECT(g->lower), "tooltip-text", _("threshold of what shall be considered underexposed"), (char *)NULL);
g_signal_connect (G_OBJECT (g->lower), "value-changed",
G_CALLBACK (lower_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->lower), TRUE, TRUE, 0);
/* upper */
g->upper = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.1, p->upper, 2);
dt_bauhaus_slider_set_format(g->upper,"%.0f%%");
dt_bauhaus_widget_set_label(g->upper,_("upper threshold"));
g_object_set(G_OBJECT(g->upper), "tooltip-text", _("threshold of what shall be considered overexposed"), (char *)NULL);
g_signal_connect (G_OBJECT (g->upper), "value-changed",
G_CALLBACK (upper_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->upper), TRUE, TRUE, 0);
/* add quicktool button for enable/disable the plugin */
GtkWidget *button = dtgtk_togglebutton_new(dtgtk_cairo_paint_overexposed, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
g_object_set(G_OBJECT(button), "tooltip-text", _("toggle over/under exposed indication"),
(char *)NULL);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (_iop_overexposed_quickbutton),
self);
dt_view_manager_module_toolbox_add(darktable.view_manager, button);
}
/** Add a new property of camera to the gui */
dt_lib_camera_property_t *_lib_property_add_new(dt_lib_camera_t *lib, const gchar *label,
const gchar *propertyname)
{
if(dt_camctl_camera_property_exists(darktable.camctl, NULL, propertyname))
{
const char *value;
if((value = dt_camctl_camera_property_get_first_choice(darktable.camctl, NULL, propertyname)) != NULL)
{
// We got a value for property lets construct the gui for the property and add values
int i = 0;
const char *current_value = dt_camctl_camera_get_property(darktable.camctl, NULL, propertyname);
dt_lib_camera_property_t *prop = calloc(1, sizeof(dt_lib_camera_property_t));
prop->name = strdup(label);
prop->property_name = strdup(propertyname);
prop->values = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(prop->values, NULL, label);
g_object_ref_sink(prop->values);
prop->osd = DTGTK_TOGGLEBUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_eye, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
g_object_ref_sink(prop->osd);
gtk_widget_set_size_request(GTK_WIDGET(prop->osd), DT_PIXEL_APPLY_DPI(14), -1);
g_object_set(G_OBJECT(prop->osd), "tooltip-text", _("toggle view property in center view"),
(char *)NULL);
do
{
dt_bauhaus_combobox_add(prop->values, g_dgettext("libgphoto2-2", value));
if(!strcmp(current_value, g_dgettext("libgphoto2-2", value)))
dt_bauhaus_combobox_set(prop->values, i);
i++;
} while((value = dt_camctl_camera_property_get_next_choice(darktable.camctl, NULL, propertyname))
!= NULL);
lib->gui.properties = g_list_append(lib->gui.properties, prop);
// Does dead lock!!!
g_signal_connect(G_OBJECT(prop->values), "value-changed", G_CALLBACK(property_changed_callback),
(gpointer)prop);
return prop;
}
}
return NULL;
}
void gui_init(dt_lib_module_t *self)
{
unsigned int i;
GtkWidget *container = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
GtkWidget *output_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5));
GtkWidget *output_options = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
GtkWidget *picker_subrow = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(2));
GtkWidget *restrict_button;
GtkWidget *samples_label = dt_ui_section_label_new(_("live samples"));
GtkWidget *samples_options_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(2));
// Initializing self data structure
dt_lib_colorpicker_t *data = (dt_lib_colorpicker_t *)calloc(1, sizeof(dt_lib_colorpicker_t));
self->data = (void *)data;
data->rgb.red = 0.7;
data->rgb.green = 0.7;
data->rgb.blue = 0.7;
data->rgb.alpha = 1.0;
// Initializing proxy functions and data
darktable.lib->proxy.colorpicker.module = self;
darktable.lib->proxy.colorpicker.size = dt_conf_get_int("ui_last/colorpicker_size");
darktable.lib->proxy.colorpicker.display_samples = dt_conf_get_int("ui_last/colorpicker_display_samples");
darktable.lib->proxy.colorpicker.live_samples = NULL;
darktable.lib->proxy.colorpicker.picked_color_rgb_mean = (uint8_t *)malloc(sizeof(uint8_t) * 3);
darktable.lib->proxy.colorpicker.picked_color_rgb_min = (uint8_t *)malloc(sizeof(uint8_t) * 3);
darktable.lib->proxy.colorpicker.picked_color_rgb_max = (uint8_t *)malloc(sizeof(uint8_t) * 3);
darktable.lib->proxy.colorpicker.picked_color_lab_mean = (float *)malloc(sizeof(float) * 3);
darktable.lib->proxy.colorpicker.picked_color_lab_min = (float *)malloc(sizeof(float) * 3);
darktable.lib->proxy.colorpicker.picked_color_lab_max = (float *)malloc(sizeof(float) * 3);
for(i = 0; i < 3; i++)
darktable.lib->proxy.colorpicker.picked_color_rgb_mean[i]
= darktable.lib->proxy.colorpicker.picked_color_rgb_min[i]
= darktable.lib->proxy.colorpicker.picked_color_rgb_max[i] = 0;
for(i = 0; i < 3; i++)
darktable.lib->proxy.colorpicker.picked_color_lab_mean[i]
= darktable.lib->proxy.colorpicker.picked_color_lab_min[i]
= darktable.lib->proxy.colorpicker.picked_color_lab_max[i] = 0;
darktable.lib->proxy.colorpicker.update_panel = _update_picker_output;
darktable.lib->proxy.colorpicker.update_samples = _update_samples_output;
darktable.lib->proxy.colorpicker.set_sample_area = _set_sample_area;
darktable.lib->proxy.colorpicker.set_sample_point = _set_sample_point;
// Setting up the GUI
self->widget = container;
gtk_box_pack_start(GTK_BOX(container), output_row, TRUE, TRUE, 0);
// The color patch
data->color_patch = gtk_drawing_area_new();
gtk_widget_set_size_request(data->color_patch, DT_PIXEL_APPLY_DPI(100), DT_PIXEL_APPLY_DPI(100));
g_signal_connect(G_OBJECT(data->color_patch), "draw", G_CALLBACK(main_draw_callback), data);
gtk_box_pack_start(GTK_BOX(output_row), data->color_patch, FALSE, FALSE, 0);
// The picker button, output selectors and label
gtk_box_pack_start(GTK_BOX(output_row), output_options, TRUE, TRUE, 0);
data->size_selector = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->size_selector), _("point"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->size_selector), _("area"));
gtk_combo_box_set_active(GTK_COMBO_BOX(data->size_selector), dt_conf_get_int("ui_last/colorpicker_size"));
gtk_widget_set_size_request(data->size_selector, DT_PIXEL_APPLY_DPI(30), -1);
gtk_box_pack_start(GTK_BOX(picker_subrow), data->size_selector, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->size_selector), "changed", G_CALLBACK(_size_changed), (gpointer)self);
data->picker_button = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_BOX);
gtk_widget_set_size_request(data->picker_button, DT_PIXEL_APPLY_DPI(50), -1);
gtk_box_pack_start(GTK_BOX(picker_subrow), data->picker_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(data->picker_button), "toggled", G_CALLBACK(_picker_button_toggled), self);
gtk_box_pack_start(GTK_BOX(output_options), picker_subrow, TRUE, TRUE, 0);
data->statistic_selector = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("mean"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("min"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("max"));
gtk_combo_box_set_active(GTK_COMBO_BOX(data->statistic_selector),
dt_conf_get_int("ui_last/colorpicker_mode"));
gtk_widget_set_sensitive(data->statistic_selector, dt_conf_get_int("ui_last/colorpicker_size"));
gtk_box_pack_start(GTK_BOX(output_options), data->statistic_selector, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->statistic_selector), "changed", G_CALLBACK(_statistic_changed), self);
data->color_mode_selector = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->color_mode_selector), _("RGB"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->color_mode_selector), _("Lab"));
gtk_combo_box_set_active(GTK_COMBO_BOX(data->color_mode_selector),
dt_conf_get_int("ui_last/colorpicker_model"));
gtk_box_pack_start(GTK_BOX(output_options), data->color_mode_selector, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->color_mode_selector), "changed", G_CALLBACK(_color_mode_changed), self);
data->output_label = gtk_label_new("");
gtk_label_set_justify(GTK_LABEL(data->output_label), GTK_JUSTIFY_CENTER);
gtk_widget_set_size_request(data->output_label, DT_PIXEL_APPLY_DPI(80), -1);
gtk_box_pack_start(GTK_BOX(output_options), data->output_label, FALSE, FALSE, 0);
restrict_button = gtk_check_button_new_with_label(_("restrict histogram to selection"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(restrict_button),
dt_conf_get_int("ui_last/colorpicker_restrict_histogram"));
darktable.lib->proxy.colorpicker.restrict_histogram
= dt_conf_get_int("ui_last/colorpicker_restrict_histogram");
gtk_box_pack_start(GTK_BOX(container), restrict_button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(restrict_button), "toggled", G_CALLBACK(_restrict_histogram_changed), NULL);
// Adding the live samples section
gtk_box_pack_start(GTK_BOX(container), samples_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(container), samples_options_row, TRUE, TRUE, 0);
data->samples_statistic_selector = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("mean"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("min"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("max"));
gtk_combo_box_set_active(GTK_COMBO_BOX(data->samples_statistic_selector),
dt_conf_get_int("ui_last/colorsamples_mode"));
gtk_box_pack_start(GTK_BOX(samples_options_row), data->samples_statistic_selector, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->samples_statistic_selector), "changed",
G_CALLBACK(_samples_statistic_changed), self);
data->samples_mode_selector = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_mode_selector), _("RGB"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_mode_selector), _("Lab"));
gtk_combo_box_set_active(GTK_COMBO_BOX(data->samples_mode_selector),
dt_conf_get_int("ui_last/colorsamples_model"));
gtk_box_pack_start(GTK_BOX(samples_options_row), data->samples_mode_selector, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->samples_mode_selector), "changed", G_CALLBACK(_samples_mode_changed), self);
data->add_sample_button = gtk_button_new_with_label(_("add"));
gtk_widget_set_sensitive(data->add_sample_button, FALSE);
gtk_box_pack_start(GTK_BOX(samples_options_row), data->add_sample_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(data->add_sample_button), "clicked", G_CALLBACK(_add_sample), self);
data->samples_container = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(2));
gtk_box_pack_start(GTK_BOX(container), data->samples_container, TRUE, TRUE, 0);
data->display_samples_check_box = gtk_check_button_new_with_label(_("display sample areas on image"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->display_samples_check_box),
dt_conf_get_int("ui_last/colorpicker_display_samples"));
gtk_box_pack_start(GTK_BOX(container), data->display_samples_check_box, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->display_samples_check_box), "toggled", G_CALLBACK(_display_samples_changed),
NULL);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_levels_gui_data_t));
dt_iop_levels_gui_data_t *c = (dt_iop_levels_gui_data_t *)self->gui_data;
c->mouse_x = c->mouse_y = -1.0;
c->dragging = 0;
c->activeToggleButton = NULL;
c->current_pick = NONE;
c->last_picked_color = -1;
for (int i=0; i<3; i++)
for (int j=0; j<2; j++) c->pick_xy_positions[i][j] = 0.5;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, 5));
c->area = GTK_DRAWING_AREA(gtk_drawing_area_new());
GtkWidget *asp = gtk_aspect_frame_new(NULL, 0.5, 0.5, 1.0, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), asp, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(asp), GTK_WIDGET(c->area));
gtk_drawing_area_size(c->area, 258, 150);
g_object_set (GTK_OBJECT(c->area), "tooltip-text", _("drag handles to set black, grey, and white points. operates on L channel."), (char *)NULL);
gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK);
g_signal_connect (G_OBJECT (c->area), "expose-event",
G_CALLBACK (dt_iop_levels_expose), self);
g_signal_connect (G_OBJECT (c->area), "button-press-event",
G_CALLBACK (dt_iop_levels_button_press), self);
g_signal_connect (G_OBJECT (c->area), "button-release-event",
G_CALLBACK (dt_iop_levels_button_release), self);
g_signal_connect (G_OBJECT (c->area), "motion-notify-event",
G_CALLBACK (dt_iop_levels_motion_notify), self);
g_signal_connect (G_OBJECT (c->area), "leave-notify-event",
G_CALLBACK (dt_iop_levels_leave_notify), self);
g_signal_connect (G_OBJECT (c->area), "scroll-event",
G_CALLBACK (dt_iop_levels_scroll), self);
GtkWidget *autobutton = dtgtk_button_new_with_label(_("auto"), NULL, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
g_object_set(G_OBJECT(autobutton), "tooltip-text", _("apply auto levels"), (char *)NULL);
gtk_widget_set_size_request(autobutton, 70, 24);
GtkWidget *blackpick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(blackpick), "tooltip-text", _("pick blackpoint from image"), (char *)NULL);
gtk_widget_set_size_request(blackpick, 24, 24);
GtkWidget *greypick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(greypick), "tooltip-text", _("pick medium greypoint from image"), (char *)NULL);
gtk_widget_set_size_request(greypick, 24, 24);
GtkWidget *whitepick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(whitepick), "tooltip-text", _("pick whitepoint from image"), (char *)NULL);
gtk_widget_set_size_request(whitepick, 24, 24);
GdkColor col;
col.red = col.green = col.blue = 0;
gtk_widget_modify_fg(GTK_WIDGET(blackpick), GTK_STATE_NORMAL, &col);
gtk_widget_modify_fg(GTK_WIDGET(blackpick), GTK_STATE_SELECTED, &col);
col.red = col.green = col.blue = 32767;
gtk_widget_modify_fg(GTK_WIDGET(greypick), GTK_STATE_NORMAL, &col);
gtk_widget_modify_fg(GTK_WIDGET(greypick), GTK_STATE_SELECTED, &col);
col.red = col.green = col.blue = 65535;
gtk_widget_modify_fg(GTK_WIDGET(whitepick), GTK_STATE_NORMAL, &col);
gtk_widget_modify_fg(GTK_WIDGET(whitepick), GTK_STATE_SELECTED, &col);
col.red = col.green = col.blue = 4096;
gtk_widget_modify_bg(GTK_WIDGET(blackpick), GTK_STATE_ACTIVE, &col);
gtk_widget_modify_bg(GTK_WIDGET(greypick), GTK_STATE_ACTIVE, &col);
gtk_widget_modify_bg(GTK_WIDGET(whitepick), GTK_STATE_ACTIVE, &col);
GtkWidget *box = gtk_hbox_new(TRUE,0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(autobutton), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(blackpick), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(greypick), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(box), GTK_WIDGET(whitepick), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT(autobutton), "clicked",
G_CALLBACK(dt_iop_levels_autoadjust_callback), (gpointer)self);
g_signal_connect (G_OBJECT(blackpick), "toggled",
G_CALLBACK (dt_iop_levels_pick_black_callback), self);
g_signal_connect (G_OBJECT(greypick), "toggled",
G_CALLBACK (dt_iop_levels_pick_grey_callback), self);
g_signal_connect (G_OBJECT(whitepick), "toggled",
G_CALLBACK (dt_iop_levels_pick_white_callback), self);
}
void dt_iop_gui_init_blendif(GtkVBox *blendw, dt_iop_module_t *module)
{
dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t*)module->blend_data;
/* create and add blendif support if module supports it */
if (bd->blendif_support)
{
int lightness=32768;
char *Lab_labels[3] = { " L ", " a ", " b " };
char *Lab_tooltips[3] = { _("sliders for L channel"), _("sliders for a channel"), _("sliders for b channel") };
char *rgb_labels[4] = { _(" gray "), _(" red "), _(" green "), _(" blue ") };
char *rgb_tooltips[4] = { _("sliders for gray value"), _("sliders for red channel"), _("sliders for green channel"), _("sliders for blue channel") };
GdkColor Lab_colors[4][3] = { { /* L channel */
(GdkColor){ 0,0,0,0 }, (GdkColor){ 0,lightness/2,lightness/2,lightness/2 }, (GdkColor){ 0,lightness,lightness,lightness }
},
{ /* a channel */
(GdkColor){ 0,0,0.34*lightness*2,0.27*lightness*2 }, (GdkColor){ 0,lightness,lightness,lightness }, (GdkColor){ 0,0.53*lightness*2,0.08*lightness*2,0.28*lightness*2 }
},
{ /* b channel */
(GdkColor){ 0,0,0.27*lightness*2,0.58*lightness*2 }, (GdkColor){ 0,lightness,lightness,lightness }, (GdkColor){ 0,0.81*lightness*2,0.66*lightness*2,0 }
},
{ /* not used */
(GdkColor){ 0,0,0,0 }, (GdkColor){ 0,0,0,0 }, (GdkColor){ 0,0,0,0 }
} };
GdkColor rgb_colors[4][3] = { { /* gray channel */
(GdkColor){ 0,0,0,0 }, (GdkColor){ 0,lightness/2,lightness/2,lightness/2 }, (GdkColor){ 0,lightness,lightness,lightness }
},
{ /* red channel */
(GdkColor){ 0,0,0,0 }, (GdkColor){ 0,lightness/2,0,0 }, (GdkColor){ 0,lightness,0,0 }
},
{ /* green channel */
(GdkColor){ 0,0,0,0 }, (GdkColor){ 0,0,lightness/2,0 }, (GdkColor){ 0,0,lightness,0 }
},
{ /* blue channel */
(GdkColor){ 0,0,0,0 }, (GdkColor){ 0,0,0,lightness/2 }, (GdkColor){ 0,0,0,lightness }
} };
char *ttinput = _("adjustment based on input received by this module:\n* range between inner markers (upper filled triangles): blend fully\n* range outside of outer markers (lower open triangles): do not blend at all\n* range between adjacent inner/outer markers: blend gradually");
char *ttoutput = _("adjustment based on unblended output of this module:\n* range between inner markers (upper filled triangles): blend fully\n* range outside of outer markers (lower open triangles): do not blend at all\n* range between adjacent inner/outer markers: blend gradually");
bd->channel = 0;
int maxchannels = 0;
char **labels = NULL;
char **tooltips = NULL;
switch(bd->csp)
{
case iop_cs_Lab:
maxchannels = 3;
labels = Lab_labels;
tooltips = Lab_tooltips;
memcpy(bd->colors, Lab_colors, sizeof(rgb_colors));
bd->scale_print[0] = _blendif_scale_print_L;
bd->scale_print[1] = _blendif_scale_print_ab;
bd->scale_print[2] = _blendif_scale_print_ab;
bd->scale_print[3] = NULL;
bd->increments[0] = 1.0f/100.0f;
bd->increments[1] = 1.0f/256.0f;
bd->increments[2] = 1.0f/256.0f;
bd->increments[3] = 1.0f;
break;
case iop_cs_rgb:
maxchannels = 4;
labels = rgb_labels;
tooltips = rgb_tooltips;
memcpy(bd->colors, rgb_colors, sizeof(rgb_colors));
bd->scale_print[0] = _blendif_scale_print_rgb;
bd->scale_print[1] = _blendif_scale_print_rgb;
bd->scale_print[2] = _blendif_scale_print_rgb;
bd->scale_print[3] = _blendif_scale_print_rgb;
bd->increments[0] = 1.0f/255.0f;
bd->increments[1] = 1.0f/255.0f;
bd->increments[2] = 1.0f/255.0f;
bd->increments[3] = 1.0f/255.0f;
break;
default:
assert(FALSE); // blendif not supported for RAW, which is already catched upstream; we should not get here
}
bd->blendif_box = GTK_VBOX(gtk_vbox_new(FALSE,DT_GUI_IOP_MODULE_CONTROL_SPACING));
GtkWidget *uplabel = gtk_hbox_new(FALSE,0);
GtkWidget *lowlabel = gtk_hbox_new(FALSE,0);
GtkWidget *notebook = gtk_hbox_new(FALSE,0);
bd->blendif_enable = dt_bauhaus_combobox_new(module);
dt_bauhaus_widget_set_label(bd->blendif_enable, _("blend"));
dt_bauhaus_combobox_add(bd->blendif_enable, _("uniformly"));
dt_bauhaus_combobox_add(bd->blendif_enable, _("only, if.."));
bd->channel_tabs = GTK_NOTEBOOK(gtk_notebook_new());
for(int ch=0; ch<maxchannels; ch++)
{
gtk_notebook_append_page(GTK_NOTEBOOK(bd->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(labels[ch]));
g_object_set(G_OBJECT(gtk_notebook_get_tab_label(bd->channel_tabs, gtk_notebook_get_nth_page(bd->channel_tabs, -1))), "tooltip-text", tooltips[ch], NULL);
}
gtk_widget_show_all(GTK_WIDGET(gtk_notebook_get_nth_page(bd->channel_tabs, bd->channel)));
gtk_notebook_set_current_page(GTK_NOTEBOOK(bd->channel_tabs), bd->channel);
g_object_set(G_OBJECT(bd->channel_tabs), "homogeneous", TRUE, (char *)NULL);
GtkWidget *tb = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(tb), "tooltip-text", _("pick gui color from image"), (char *)NULL);
GtkWidget *sm = dtgtk_togglebutton_new(dtgtk_cairo_paint_showmask, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(sm), "tooltip-text", _("display mask"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(notebook), GTK_WIDGET(bd->channel_tabs), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(notebook), GTK_WIDGET(tb), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(notebook), GTK_WIDGET(sm), FALSE, FALSE, 0);
bd->lower_slider = DTGTK_GRADIENT_SLIDER_MULTIVALUE(dtgtk_gradient_slider_multivalue_new(4));
bd->upper_slider = DTGTK_GRADIENT_SLIDER_MULTIVALUE(dtgtk_gradient_slider_multivalue_new(4));
dtgtk_gradient_slider_multivalue_set_marker(bd->lower_slider, GRADIENT_SLIDER_MARKER_LOWER_OPEN_BIG, 0);
dtgtk_gradient_slider_multivalue_set_marker(bd->lower_slider, GRADIENT_SLIDER_MARKER_UPPER_FILLED_BIG, 1);
dtgtk_gradient_slider_multivalue_set_marker(bd->lower_slider, GRADIENT_SLIDER_MARKER_UPPER_FILLED_BIG, 2);
dtgtk_gradient_slider_multivalue_set_marker(bd->lower_slider, GRADIENT_SLIDER_MARKER_LOWER_OPEN_BIG, 3);
dtgtk_gradient_slider_multivalue_set_marker(bd->upper_slider, GRADIENT_SLIDER_MARKER_LOWER_OPEN_BIG, 0);
dtgtk_gradient_slider_multivalue_set_marker(bd->upper_slider, GRADIENT_SLIDER_MARKER_UPPER_FILLED_BIG, 1);
dtgtk_gradient_slider_multivalue_set_marker(bd->upper_slider, GRADIENT_SLIDER_MARKER_UPPER_FILLED_BIG, 2);
dtgtk_gradient_slider_multivalue_set_marker(bd->upper_slider, GRADIENT_SLIDER_MARKER_LOWER_OPEN_BIG, 3);
dtgtk_gradient_slider_multivalue_set_stop(bd->lower_slider, 0.0f, bd->colors[bd->channel][0]);
dtgtk_gradient_slider_multivalue_set_stop(bd->lower_slider, 0.5f, bd->colors[bd->channel][1]);
dtgtk_gradient_slider_multivalue_set_stop(bd->lower_slider, 1.0f, bd->colors[bd->channel][2]);
dtgtk_gradient_slider_multivalue_set_stop(bd->upper_slider, 0.0f, bd->colors[bd->channel][0]);
dtgtk_gradient_slider_multivalue_set_stop(bd->upper_slider, 0.5f, bd->colors[bd->channel][1]);
dtgtk_gradient_slider_multivalue_set_stop(bd->upper_slider, 1.0f, bd->colors[bd->channel][2]);
GtkWidget *output = gtk_label_new(_("output"));
bd->upper_picker_label = GTK_LABEL(gtk_label_new(""));
gtk_box_pack_start(GTK_BOX(uplabel), GTK_WIDGET(output), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(uplabel), GTK_WIDGET(bd->upper_picker_label), TRUE, TRUE, 0);
for(int k=0; k < 4 ; k++)
{
bd->upper_label[k] = GTK_LABEL(gtk_label_new(NULL));
gtk_label_set_width_chars(bd->upper_label[k], 6);
gtk_box_pack_start(GTK_BOX(uplabel), GTK_WIDGET(bd->upper_label[k]), FALSE, FALSE, 0);
}
GtkWidget *input = gtk_label_new(_("input"));
bd->lower_picker_label = GTK_LABEL(gtk_label_new(""));
gtk_box_pack_start(GTK_BOX(lowlabel), GTK_WIDGET(input), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lowlabel), GTK_WIDGET(bd->lower_picker_label), TRUE, TRUE, 0);
for(int k=0; k < 4 ; k++)
{
bd->lower_label[k] = GTK_LABEL(gtk_label_new(NULL));
gtk_label_set_width_chars(bd->lower_label[k], 6);
gtk_box_pack_start(GTK_BOX(lowlabel), GTK_WIDGET(bd->lower_label[k]), FALSE, FALSE, 0);
}
gtk_object_set(GTK_OBJECT(bd->blendif_enable), "tooltip-text", _("enable conditional blending"), (char *)NULL);
gtk_object_set(GTK_OBJECT(bd->lower_slider), "tooltip-text", _("double click to reset"), (char *)NULL);
gtk_object_set(GTK_OBJECT(bd->upper_slider), "tooltip-text", _("double click to reset"), (char *)NULL);
gtk_object_set(GTK_OBJECT(output), "tooltip-text", ttoutput, (char *)NULL);
gtk_object_set(GTK_OBJECT(input), "tooltip-text", ttinput, (char *)NULL);
g_signal_connect (G_OBJECT (bd->lower_slider), "expose-event",
G_CALLBACK (_blendop_blendif_expose), module);
g_signal_connect (G_OBJECT (bd->upper_slider), "expose-event",
G_CALLBACK (_blendop_blendif_expose), module);
g_signal_connect (G_OBJECT (bd->blendif_enable), "value-changed",
G_CALLBACK (_blendop_blendif_callback), bd);
g_signal_connect(G_OBJECT (bd->channel_tabs), "switch_page",
G_CALLBACK (_blendop_blendif_tab_switch), bd);
g_signal_connect (G_OBJECT (bd->upper_slider), "value-changed",
G_CALLBACK (_blendop_blendif_upper_callback), bd);
g_signal_connect (G_OBJECT (bd->lower_slider), "value-changed",
G_CALLBACK (_blendop_blendif_lower_callback), bd);
g_signal_connect (G_OBJECT(tb), "toggled",
G_CALLBACK (_blendop_blendif_pick_toggled), module);
g_signal_connect (G_OBJECT(sm), "toggled",
G_CALLBACK (_blendop_blendif_showmask_toggled), module);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(notebook), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(uplabel), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(bd->upper_slider), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(lowlabel), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(bd->lower_slider), TRUE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(blendw), GTK_WIDGET(bd->blendif_box),TRUE,TRUE,0);
gtk_box_pack_end(GTK_BOX(blendw), GTK_WIDGET(bd->blendif_enable),TRUE,TRUE,0);
}
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_borders_gui_data_t));
dt_iop_borders_gui_data_t *g = (dt_iop_borders_gui_data_t *)self->gui_data;
dt_iop_borders_params_t *p = (dt_iop_borders_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
g->size = dt_bauhaus_slider_new_with_range(self, 0.0, 50.0, 0.5, p->size * 100.0, 2);
dt_bauhaus_widget_set_label(g->size, NULL, _("border size"));
dt_bauhaus_slider_set_format(g->size, "%.2f%%");
g_signal_connect(G_OBJECT(g->size), "value-changed", G_CALLBACK(size_callback), self);
gtk_widget_set_tooltip_text(g->size, _("size of the border in percent of the full image"));
gtk_box_pack_start(GTK_BOX(self->widget), g->size, TRUE, TRUE, 0);
g->aspect = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->aspect, 1);
dt_bauhaus_widget_set_label(g->aspect, NULL, _("aspect"));
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect, TRUE, TRUE, 0);
gui_init_aspect(self);
g_signal_connect(G_OBJECT(g->aspect), "value-changed", G_CALLBACK(aspect_changed), self);
gtk_widget_set_tooltip_text(g->aspect, _("select the aspect ratio or right click and type your own (w:h)"));
g->aspect_orient = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->aspect_orient, NULL, _("orientation"));
dt_bauhaus_combobox_add(g->aspect_orient, _("auto"));
dt_bauhaus_combobox_add(g->aspect_orient, _("portrait"));
dt_bauhaus_combobox_add(g->aspect_orient, _("landscape"));
gtk_widget_set_tooltip_text(g->aspect_orient, _("aspect ratio orientation of the image with border"));
g_signal_connect(G_OBJECT(g->aspect_orient), "value-changed", G_CALLBACK(aspect_orient_changed), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect_orient, TRUE, TRUE, 0);
g->pos_h = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->pos_h, 1);
dt_bauhaus_widget_set_label(g->pos_h, NULL, _("horizontal position"));
gtk_box_pack_start(GTK_BOX(self->widget), g->pos_h, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(g->pos_h), "value-changed", G_CALLBACK(position_h_changed), self);
gtk_widget_set_tooltip_text(g->pos_h, _("select the horizontal position ratio relative to top "
"or right click and type your own (y:h)"));
g->pos_v = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->pos_v, 1);
dt_bauhaus_widget_set_label(g->pos_v, NULL, _("vertical position"));
gtk_box_pack_start(GTK_BOX(self->widget), g->pos_v, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(g->pos_v), "value-changed", G_CALLBACK(position_v_changed), self);
gtk_widget_set_tooltip_text(g->pos_v, _("select the vertical position ratio relative to left "
"or right click and type your own (x:w)"));
gui_init_positions(self);
g->frame_size = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_size * 100.0, 2);
dt_bauhaus_widget_set_label(g->frame_size, NULL, _("frame line size"));
dt_bauhaus_slider_set_format(g->frame_size, "%.2f%%");
g_signal_connect(G_OBJECT(g->frame_size), "value-changed", G_CALLBACK(frame_size_callback), self);
gtk_widget_set_tooltip_text(g->frame_size, _("size of the frame line in percent of min border width"));
gtk_box_pack_start(GTK_BOX(self->widget), g->frame_size, TRUE, TRUE, 0);
g->frame_offset = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_offset * 100.0, 2);
dt_bauhaus_widget_set_label(g->frame_offset, NULL, _("frame line offset"));
dt_bauhaus_slider_set_format(g->frame_offset, "%.2f%%");
g_signal_connect(G_OBJECT(g->frame_offset), "value-changed", G_CALLBACK(frame_offset_callback), self);
gtk_widget_set_tooltip_text(g->frame_offset, _("offset of the frame line beginning on picture side"));
gtk_box_pack_start(GTK_BOX(self->widget), g->frame_offset, TRUE, TRUE, 0);
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
g->colorpick = gtk_color_button_new_with_rgba(&color);
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select border color"));
GtkWidget *label = dtgtk_reset_label_new(_("border color"), self, &p->color, 3 * sizeof(float));
g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self);
g->border_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
gtk_widget_set_tooltip_text(GTK_WIDGET(g->border_picker), _("pick border color from image"));
gtk_widget_set_size_request(GTK_WIDGET(g->border_picker), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
g_signal_connect(G_OBJECT(g->border_picker), "toggled", G_CALLBACK(request_pick_toggled_border), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->border_picker), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
g->frame_colorpick = gtk_color_button_new_with_rgba(&color);
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->frame_colorpick), FALSE);
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->frame_colorpick), _("select frame line color"));
gtk_widget_set_size_request(GTK_WIDGET(g->frame_colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
label = dtgtk_reset_label_new(_("frame line color"), self, &p->color, 3 * sizeof(float));
g_signal_connect(G_OBJECT(g->frame_colorpick), "color-set", G_CALLBACK(frame_colorpick_color_set), self);
g->frame_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
gtk_widget_set_tooltip_text(GTK_WIDGET(g->frame_picker), _("pick frame line color from image"));
gtk_widget_set_size_request(GTK_WIDGET(g->frame_picker), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
g_signal_connect(G_OBJECT(g->frame_picker), "toggled", G_CALLBACK(request_pick_toggled_frame), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_picker), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(borders_draw), self);
}
void reload_defaults(dt_iop_module_t *self)
{
dt_iop_borders_params_t tmp = (dt_iop_borders_params_t){ { 1.0f, 1.0f, 1.0f },
DT_IOP_BORDERS_ASPECT_CONSTANT_VALUE,
"constant border",
0,
0.1f,
0.5f,
"1/2",
0.5f,
"1/2",
0.0f,
0.5f,
{ 0.0f, 0.0f, 0.0f },
TRUE };
memcpy(self->params, &tmp, sizeof(dt_iop_borders_params_t));
memcpy(self->default_params, &tmp, sizeof(dt_iop_borders_params_t));
self->default_enabled = 0;
}
void gui_init(dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_levels_gui_data_t));
dt_iop_levels_gui_data_t *c = (dt_iop_levels_gui_data_t *)self->gui_data;
dt_iop_levels_params_t *p = (dt_iop_levels_params_t *)self->params;
dt_pthread_mutex_init(&c->lock, NULL);
dt_pthread_mutex_lock(&c->lock);
c->auto_levels[0] = NAN;
c->auto_levels[1] = NAN;
c->auto_levels[2] = NAN;
dt_pthread_mutex_unlock(&c->lock);
c->modes = NULL;
c->mouse_x = c->mouse_y = -1.0;
c->dragging = 0;
c->activeToggleButton = NULL;
c->current_pick = NONE;
c->last_picked_color = -1;
for(int i = 0; i < 3; i++)
for(int j = 0; j < 2; j++) c->pick_xy_positions[i][j] = -1;
self->widget = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
c->mode = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(c->mode, NULL, _("mode"));
dt_bauhaus_combobox_add(c->mode, C_("mode", "manual"));
c->modes = g_list_append(c->modes, GUINT_TO_POINTER(LEVELS_MODE_MANUAL));
dt_bauhaus_combobox_add(c->mode, _("automatic"));
c->modes = g_list_append(c->modes, GUINT_TO_POINTER(LEVELS_MODE_AUTOMATIC));
dt_bauhaus_combobox_set_default(c->mode, LEVELS_MODE_MANUAL);
dt_bauhaus_combobox_set(c->mode, g_list_index(c->modes, GUINT_TO_POINTER(p->mode)));
gtk_box_pack_start(GTK_BOX(self->widget), c->mode, TRUE, TRUE, 0);
c->mode_stack = gtk_stack_new();
gtk_stack_set_homogeneous(GTK_STACK(c->mode_stack),FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), c->mode_stack, TRUE, TRUE, 0);
c->area = GTK_DRAWING_AREA(dtgtk_drawing_area_new_with_aspect_ratio(9.0 / 16.0));
GtkWidget *vbox_manual = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
gtk_box_pack_start(GTK_BOX(vbox_manual), GTK_WIDGET(c->area), TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(GTK_WIDGET(c->area),_("drag handles to set black, gray, and white points. "
"operates on L channel."));
gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_LEAVE_NOTIFY_MASK | GDK_SCROLL_MASK);
g_signal_connect(G_OBJECT(c->area), "draw", G_CALLBACK(dt_iop_levels_area_draw), self);
g_signal_connect(G_OBJECT(c->area), "button-press-event", G_CALLBACK(dt_iop_levels_button_press), self);
g_signal_connect(G_OBJECT(c->area), "button-release-event", G_CALLBACK(dt_iop_levels_button_release), self);
g_signal_connect(G_OBJECT(c->area), "motion-notify-event", G_CALLBACK(dt_iop_levels_motion_notify), self);
g_signal_connect(G_OBJECT(c->area), "leave-notify-event", G_CALLBACK(dt_iop_levels_leave_notify), self);
g_signal_connect(G_OBJECT(c->area), "scroll-event", G_CALLBACK(dt_iop_levels_scroll), self);
GtkWidget *autobutton = gtk_button_new_with_label(_("auto"));
gtk_widget_set_tooltip_text(autobutton, _("apply auto levels"));
gtk_widget_set_size_request(autobutton, -1, DT_PIXEL_APPLY_DPI(24));
GtkWidget *blackpick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
gtk_widget_set_tooltip_text(blackpick, _("pick black point from image"));
GtkWidget *greypick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
gtk_widget_set_tooltip_text(greypick, _("pick medium gray point from image"));
GtkWidget *whitepick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
gtk_widget_set_tooltip_text(whitepick, _("pick white point from image"));
GdkRGBA color = { 0 };
color.alpha = 1.0;
dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(blackpick), &color);
color.red = color.green = color.blue = 0.5;
dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(greypick), &color);
color.red = color.green = color.blue = 1.0;
dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(whitepick), &color);
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(autobutton), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(blackpick), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(greypick), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(box), GTK_WIDGET(whitepick), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_manual), box, TRUE, TRUE, 0);
gtk_widget_show_all(vbox_manual);
gtk_stack_add_named(GTK_STACK(c->mode_stack), vbox_manual, "manual");
c->percentile_black = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[0], 3);
gtk_widget_set_tooltip_text(c->percentile_black, _("black percentile"));
dt_bauhaus_slider_set_format(c->percentile_black, "%.1f%%");
dt_bauhaus_widget_set_label(c->percentile_black, NULL, _("black"));
c->percentile_grey = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[1], 3);
gtk_widget_set_tooltip_text(c->percentile_grey, _("gray percentile"));
dt_bauhaus_slider_set_format(c->percentile_grey, "%.1f%%");
dt_bauhaus_widget_set_label(c->percentile_grey, NULL, _("gray"));
c->percentile_white = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[2], 3);
gtk_widget_set_tooltip_text(c->percentile_white, _("white percentile"));
dt_bauhaus_slider_set_format(c->percentile_white, "%.1f%%");
dt_bauhaus_widget_set_label(c->percentile_white, NULL, _("white"));
GtkWidget *vbox_automatic = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_black), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_grey), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_white), FALSE, FALSE, 0);
gtk_widget_show_all(vbox_automatic);
gtk_stack_add_named(GTK_STACK(c->mode_stack), vbox_automatic, "automatic");
switch(p->mode)
{
case LEVELS_MODE_AUTOMATIC:
gtk_stack_set_visible_child_name(GTK_STACK(c->mode_stack), "automatic");
break;
case LEVELS_MODE_MANUAL:
default:
gtk_stack_set_visible_child_name(GTK_STACK(c->mode_stack), "manual");
break;
}
g_signal_connect(G_OBJECT(c->mode), "value-changed", G_CALLBACK(dt_iop_levels_mode_callback), self);
g_signal_connect(G_OBJECT(c->percentile_black), "value-changed",
G_CALLBACK(dt_iop_levels_percentiles_callback), self);
g_signal_connect(G_OBJECT(c->percentile_grey), "value-changed",
G_CALLBACK(dt_iop_levels_percentiles_callback), self);
g_signal_connect(G_OBJECT(c->percentile_white), "value-changed",
G_CALLBACK(dt_iop_levels_percentiles_callback), self);
g_signal_connect(G_OBJECT(autobutton), "clicked", G_CALLBACK(dt_iop_levels_autoadjust_callback),
(gpointer)self);
g_signal_connect(G_OBJECT(blackpick), "toggled", G_CALLBACK(dt_iop_levels_pick_black_callback), self);
g_signal_connect(G_OBJECT(greypick), "toggled", G_CALLBACK(dt_iop_levels_pick_grey_callback), self);
g_signal_connect(G_OBJECT(whitepick), "toggled", G_CALLBACK(dt_iop_levels_pick_white_callback), self);
}
void
gui_init (dt_lib_module_t *self)
{
self->data = malloc(sizeof(dt_lib_live_view_t));
memset(self->data,0,sizeof(dt_lib_live_view_t));
// Setup lib data
dt_lib_live_view_t *lib=self->data;
// Setup gui
self->widget = gtk_vbox_new(FALSE, 5);
GtkWidget *box, *label;
box = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
lib->live_view = dtgtk_togglebutton_new(dtgtk_cairo_paint_eye, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
lib->rotate_ccw = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
lib->rotate_cw = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER|1);
gtk_box_pack_start(GTK_BOX(box), lib->live_view, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->rotate_ccw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->rotate_cw, TRUE, TRUE, 0);
g_object_set(G_OBJECT( lib->live_view), "tooltip-text", _("toggle live view"), (char *)NULL);
g_object_set(G_OBJECT( lib->rotate_ccw), "tooltip-text", _("rotate 90 degrees ccw"), (char *)NULL);
g_object_set(G_OBJECT( lib->rotate_cw), "tooltip-text", _("rotate 90 degrees cw"), (char *)NULL);
g_signal_connect(G_OBJECT(lib->live_view), "clicked", G_CALLBACK(_toggle_live_view_clicked), lib);
g_signal_connect(G_OBJECT(lib->rotate_ccw), "clicked", G_CALLBACK(_rotate_ccw), lib);
g_signal_connect(G_OBJECT(lib->rotate_cw), "clicked", G_CALLBACK(_rotate_cw), lib);
// focus buttons
box = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
lib->focus_in_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER|CPF_DIRECTION_LEFT);
lib->focus_in_small = dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER|CPF_DIRECTION_LEFT);
lib->focus_out_small = dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER|CPF_DIRECTION_RIGHT);
lib->focus_out_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER|CPF_DIRECTION_RIGHT);
gtk_box_pack_start(GTK_BOX(box), lib->focus_in_big, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_in_small, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_out_small, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_out_big, TRUE, TRUE, 0);
g_object_set(G_OBJECT( lib->focus_in_big), "tooltip-text", _("move focus point in (big steps)"), (char *)NULL);
g_object_set(G_OBJECT( lib->focus_in_small), "tooltip-text", _("move focus point in (small steps)"), (char *)NULL);
g_object_set(G_OBJECT( lib->focus_out_small), "tooltip-text", _("move focus point out (small steps)"), (char *)NULL);
g_object_set(G_OBJECT( lib->focus_out_big), "tooltip-text", _("move focus point out (big steps)"), (char *)NULL);
// 1 and 4 would be medium steps, not in ui right now ...
g_signal_connect(G_OBJECT(lib->focus_in_big), "clicked", G_CALLBACK(_focus_button_clicked), (gpointer)0);
g_signal_connect(G_OBJECT(lib->focus_in_small), "clicked", G_CALLBACK(_focus_button_clicked), (gpointer)2);
g_signal_connect(G_OBJECT(lib->focus_out_small), "clicked", G_CALLBACK(_focus_button_clicked), (gpointer)3);
g_signal_connect(G_OBJECT(lib->focus_out_big), "clicked", G_CALLBACK(_focus_button_clicked), (gpointer)5);
// Guides
label = GTK_WIDGET(dtgtk_label_new(_("guides"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT));
gtk_box_pack_start(GTK_BOX(self->widget), label, TRUE, TRUE, 0);
lib->guide_selector = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(lib->guide_selector), _("none"));
gtk_combo_box_append_text(GTK_COMBO_BOX(lib->guide_selector), _("grid"));
gtk_combo_box_append_text(GTK_COMBO_BOX(lib->guide_selector), _("rules of thirds"));
gtk_combo_box_append_text(GTK_COMBO_BOX(lib->guide_selector), _("diagonal method"));
gtk_combo_box_append_text(GTK_COMBO_BOX(lib->guide_selector), _("harmonious triangles"));
gtk_combo_box_append_text(GTK_COMBO_BOX(lib->guide_selector), _("golden mean"));
gtk_combo_box_set_active(GTK_COMBO_BOX(lib->guide_selector), GUIDE_NONE);
g_object_set(G_OBJECT(lib->guide_selector), "tooltip-text", _("with this option, you can display guide lines to help compose your photograph."), (char *)NULL);
g_signal_connect (G_OBJECT (lib->guide_selector), "changed", G_CALLBACK (guides_presets_changed), lib);
label = gtk_label_new(_("type"));
box = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->guide_selector, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
/*-------------------------------------------*/
lib->flipBox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), lib->flipBox, TRUE, TRUE, 0);
lib->flipLabel = gtk_label_new(_("flip"));
gtk_misc_set_alignment(GTK_MISC(lib->flipLabel), 0.0, 0.5);
lib->flipHorGoldenGuide = dtgtk_togglebutton_new(dtgtk_cairo_paint_flip,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER|CPF_DIRECTION_UP);
lib->flipVerGoldenGuide = dtgtk_togglebutton_new(dtgtk_cairo_paint_flip,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
gtk_box_pack_start(GTK_BOX(lib->flipBox), lib->flipLabel, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(lib->flipBox), lib->flipHorGoldenGuide, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(lib->flipBox), lib->flipVerGoldenGuide, TRUE, TRUE, 0);
g_object_set(G_OBJECT(lib->flipHorGoldenGuide), "tooltip-text", _("flip guides horizontally"), (char *)NULL);
g_object_set(G_OBJECT(lib->flipVerGoldenGuide), "tooltip-text", _("flip guides vertically"), (char *)NULL);
/*-------------------------------------------*/
lib->goldenTable = gtk_table_new(3, 3, FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), lib->goldenTable, TRUE, TRUE, 0);
gtk_table_set_row_spacings(GTK_TABLE(lib->goldenTable), DT_GUI_IOP_MODULE_CONTROL_SPACING);
gtk_table_set_col_spacings(GTK_TABLE(lib->goldenTable), DT_GUI_IOP_MODULE_CONTROL_SPACING);
lib->goldenSectionBox = gtk_check_button_new_with_label(_("golden sections"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lib->goldenSectionBox), TRUE);
g_object_set(G_OBJECT(lib->goldenSectionBox), "tooltip-text", _("enable this option to show golden sections."), (char *)NULL);
gtk_table_attach(GTK_TABLE(lib->goldenTable), lib->goldenSectionBox, 0, 1, 0, 1, GTK_EXPAND|GTK_FILL, 0, 0, 0);
lib->goldenSpiralSectionBox = gtk_check_button_new_with_label(_("spiral sections"));
g_object_set(G_OBJECT(lib->goldenSpiralSectionBox), "tooltip-text", _("enable this option to show golden spiral sections."), (char *)NULL);
gtk_table_attach(GTK_TABLE(lib->goldenTable), lib->goldenSpiralSectionBox, 1, 2, 0, 1, GTK_EXPAND|GTK_FILL, 0, 0, 0);
lib->goldenSpiralBox = gtk_check_button_new_with_label(_("golden spiral"));
g_object_set(G_OBJECT(lib->goldenSpiralBox), "tooltip-text", _("enable this option to show a golden spiral guide."), (char *)NULL);
gtk_table_attach(GTK_TABLE(lib->goldenTable), lib->goldenSpiralBox, 0, 1, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0);
lib->goldenTriangleBox = gtk_check_button_new_with_label(_("golden triangles"));
g_object_set(G_OBJECT(lib->goldenTriangleBox), "tooltip-text", _("enable this option to show golden triangles."), (char *)NULL);
gtk_table_attach(GTK_TABLE(lib->goldenTable), lib->goldenTriangleBox, 1, 2, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0);
gtk_widget_set_visible(GTK_WIDGET(lib->flipBox), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->flipLabel), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->flipHorGoldenGuide), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->flipVerGoldenGuide), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->goldenTable), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->goldenSectionBox), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->goldenSpiralSectionBox), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->goldenSpiralBox), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->goldenTriangleBox), FALSE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->flipBox), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->flipLabel), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->flipHorGoldenGuide), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->flipVerGoldenGuide), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->goldenTable), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->goldenSectionBox), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->goldenSpiralSectionBox), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->goldenSpiralBox), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->goldenTriangleBox), TRUE);
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_modulegroups_t *d = (dt_lib_modulegroups_t *)g_malloc(sizeof(dt_lib_modulegroups_t));
self->data = (void *)d;
memset(d,0,sizeof(dt_lib_modulegroups_t));
self->widget = gtk_hbox_new(TRUE,2);
dtgtk_cairo_paint_flags_t pf = CPF_STYLE_FLAT;
/* favorites */
d->buttons[DT_MODULEGROUP_FAVORITES] = dtgtk_togglebutton_new(dtgtk_cairo_paint_modulegroup_favorites, pf);
g_signal_connect (d->buttons[DT_MODULEGROUP_FAVORITES], "toggled", G_CALLBACK (_lib_modulegroups_toggle),self);
g_object_set (d->buttons[DT_MODULEGROUP_FAVORITES],"tooltip-text",_("show modules explicit specified by user"),(char *)NULL);
/* active */
d->buttons[DT_MODULEGROUP_ACTIVE_PIPE] = dtgtk_togglebutton_new(dtgtk_cairo_paint_modulegroup_active, pf);
g_signal_connect (d->buttons[DT_MODULEGROUP_ACTIVE_PIPE], "toggled", G_CALLBACK (_lib_modulegroups_toggle),self);
g_object_set (d->buttons[DT_MODULEGROUP_ACTIVE_PIPE],"tooltip-text",_("the modules used in active pipe"),(char *)NULL);
/* basic */
d->buttons[DT_MODULEGROUP_BASIC] = dtgtk_togglebutton_new(dtgtk_cairo_paint_modulegroup_basic, pf);
g_signal_connect (d->buttons[DT_MODULEGROUP_BASIC], "toggled", G_CALLBACK (_lib_modulegroups_toggle),self);
g_object_set (d->buttons[DT_MODULEGROUP_BASIC],"tooltip-text",_("basic group"),(char *)NULL);
/* correct */
d->buttons[DT_MODULEGROUP_CORRECT] = dtgtk_togglebutton_new(dtgtk_cairo_paint_modulegroup_correct, pf);
g_signal_connect (d->buttons[DT_MODULEGROUP_CORRECT], "toggled", G_CALLBACK (_lib_modulegroups_toggle),self);
g_object_set (d->buttons[DT_MODULEGROUP_CORRECT],"tooltip-text",_("correction group"),(char *)NULL);
/* color */
d->buttons[DT_MODULEGROUP_COLOR] = dtgtk_togglebutton_new(dtgtk_cairo_paint_modulegroup_color, pf);
g_signal_connect (d->buttons[DT_MODULEGROUP_COLOR], "toggled", G_CALLBACK (_lib_modulegroups_toggle),self);
g_object_set (d->buttons[DT_MODULEGROUP_COLOR],"tooltip-text",_("color group"),(char *)NULL);
/* tone */
d->buttons[DT_MODULEGROUP_TONE] = dtgtk_togglebutton_new(dtgtk_cairo_paint_modulegroup_tone, pf);
g_signal_connect (d->buttons[DT_MODULEGROUP_TONE], "toggled", G_CALLBACK (_lib_modulegroups_toggle),self);
g_object_set (d->buttons[DT_MODULEGROUP_TONE],"tooltip-text",_("tone group"),(char *)NULL);
/* effect */
d->buttons[DT_MODULEGROUP_EFFECT] = dtgtk_togglebutton_new(dtgtk_cairo_paint_modulegroup_effect, pf);
g_signal_connect (d->buttons[DT_MODULEGROUP_EFFECT], "toggled", G_CALLBACK (_lib_modulegroups_toggle),self);
g_object_set (d->buttons[DT_MODULEGROUP_EFFECT],"tooltip-text",_("effect group"),(char *)NULL);
/* minimize table height before adding the buttons */
gtk_widget_set_size_request(self->widget,-1,-1);
/*
* layout button row
*/
int iconsize = 28;
GtkWidget *br = self->widget;
for (int k=0; k<DT_MODULEGROUP_SIZE; k++)
{
gtk_widget_set_size_request(d->buttons[k], iconsize, iconsize);
gtk_box_pack_start(GTK_BOX(br), d->buttons[k], TRUE, TRUE, 0);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->buttons[d->current]), TRUE);
gtk_widget_show_all(self->widget);
/*
* set the proxy functions
*/
darktable.develop->proxy.modulegroups.module = self;
darktable.develop->proxy.modulegroups.set = _lib_modulegroups_set;
darktable.develop->proxy.modulegroups.get = _lib_modulegroups_get;
darktable.develop->proxy.modulegroups.test = _lib_modulegroups_test;
darktable.develop->proxy.modulegroups.switch_group = _lib_modulegroups_switch_group;
/* let's connect to view changed signal to set default group */
dt_control_signal_connect(darktable.signals,
DT_SIGNAL_VIEWMANAGER_VIEW_CHANGED,
G_CALLBACK(_lib_modulegroups_viewchanged_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_watermark_gui_data_t));
dt_iop_watermark_gui_data_t *g = (dt_iop_watermark_gui_data_t *)self->gui_data;
dt_iop_watermark_params_t *p = (dt_iop_watermark_params_t *)self->params;
int line = 0;
self->widget = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_BAUHAUS_SPACE);
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10));
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("content")), 0, line++, 3, 1);
// Add the marker combobox
gchar configdir[PATH_MAX] = { 0 };
gchar datadir[PATH_MAX] = { 0 };
dt_loc_get_datadir(datadir, sizeof(datadir));
dt_loc_get_user_config_dir(configdir, sizeof(configdir));
GtkWidget *label = dtgtk_reset_label_new(_("marker"), self, &p->filename, sizeof(p->filename));
g->watermarks = dt_bauhaus_combobox_new(self);
gtk_widget_set_hexpand(GTK_WIDGET(g->watermarks), TRUE);
char *tooltip = g_strdup_printf(_("SVG watermarks in %s/watermarks or %s/watermarks"), configdir, datadir);
gtk_widget_set_tooltip_text(g->watermarks, tooltip);
g_free(tooltip);
g->refresh = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->watermarks, label, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->refresh, g->watermarks, GTK_POS_RIGHT, 1, 1);
// Watermark color
float red = dt_conf_get_float("plugins/darkroom/watermark/color_red");
float green = dt_conf_get_float("plugins/darkroom/watermark/color_green");
float blue = dt_conf_get_float("plugins/darkroom/watermark/color_blue");
GdkRGBA color = (GdkRGBA){.red = red, .green = green, .blue = blue, .alpha = 1.0 };
label = dtgtk_reset_label_new(_("color"), self, &p->color, 3 * sizeof(float));
g->colorpick = gtk_color_button_new_with_rgba(&color);
gtk_widget_set_tooltip_text(g->colorpick, _("watermark color, tag:\n$(WATERMARK_COLOR)"));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select watermark color"));
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->colorpick, label, GTK_POS_RIGHT, 2, 1);
// Simple text
label = gtk_label_new(_("text"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
g->text = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(g->text), 1);
gtk_widget_set_tooltip_text(g->text, _("text string, tag:\n$(WATERMARK_TEXT)"));
dt_gui_key_accel_block_on_focus_connect(g->text);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->text, label, GTK_POS_RIGHT, 2, 1);
gchar *str = dt_conf_get_string("plugins/darkroom/watermark/text");
gtk_entry_set_text(GTK_ENTRY(g->text), str);
g_free(str);
// Text font
label = dtgtk_reset_label_new(_("font"), self, &p->font, sizeof(p->font));
str = dt_conf_get_string("plugins/darkroom/watermark/font");
g->fontsel = gtk_font_button_new_with_font(str==NULL?"DejaVu Sans 10":str);
GList *childs = gtk_container_get_children(GTK_CONTAINER(gtk_bin_get_child(GTK_BIN(g->fontsel))));
gtk_label_set_ellipsize(GTK_LABEL(childs->data), PANGO_ELLIPSIZE_MIDDLE);
g_list_free(childs);
gtk_widget_set_tooltip_text(g->fontsel, _("text font, tags:\n$(WATERMARK_FONT_FAMILY)\n"
"$(WATERMARK_FONT_STYLE)\n$(WATERMARK_FONT_WEIGHT)"));
gtk_font_button_set_show_size (GTK_FONT_BUTTON(g->fontsel), FALSE);
g_free(str);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->fontsel, label, GTK_POS_RIGHT, 2, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("properties")), 0, line++, 3, 1);
// Add opacity/scale sliders to table
g->opacity = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->opacity, 0);
dt_bauhaus_slider_set_format(g->opacity, "%.f%%");
dt_bauhaus_widget_set_label(g->opacity, NULL, _("opacity"));
g->scale = dt_bauhaus_slider_new_with_range(self, 1.0, 100.0, 1.0, p->scale, 0);
dt_bauhaus_slider_enable_soft_boundaries(g->scale, 1.0, 500.0);
dt_bauhaus_slider_set_format(g->scale, "%.f%%");
dt_bauhaus_widget_set_label(g->scale, NULL, _("scale"));
g->rotate = dt_bauhaus_slider_new_with_range(self, -180.0, 180.0, 1.0, p->rotate, 2);
dt_bauhaus_slider_set_format(g->rotate, "%.02f°");
dt_bauhaus_widget_set_label(g->rotate, NULL, _("rotation"));
gtk_grid_attach(GTK_GRID(self->widget), g->opacity, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->scale, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->rotate, 0, line++, 3, 1);
g->sizeto = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_add(g->sizeto, C_("size", "image"));
dt_bauhaus_combobox_add(g->sizeto, _("larger border"));
dt_bauhaus_combobox_add(g->sizeto, _("smaller border"));
dt_bauhaus_combobox_set(g->sizeto, p->sizeto);
dt_bauhaus_widget_set_label(g->sizeto, NULL, _("scale on"));
gtk_widget_set_tooltip_text(g->sizeto, _("size is relative to"));
gtk_grid_attach(GTK_GRID(self->widget), g->sizeto, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("position")), 0, line++, 3, 1);
// Create the 3x3 gtk table toggle button table...
label = dtgtk_reset_label_new(_("alignment"), self, &p->alignment, sizeof(p->alignment));
GtkWidget *bat = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
gtk_grid_set_column_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
for(int i = 0; i < 9; i++)
{
g->align[i] = dtgtk_togglebutton_new(dtgtk_cairo_paint_alignment, CPF_STYLE_FLAT | (CPF_SPECIAL_FLAG << i));
gtk_widget_set_size_request(GTK_WIDGET(g->align[i]), DT_PIXEL_APPLY_DPI(16), DT_PIXEL_APPLY_DPI(16));
gtk_grid_attach(GTK_GRID(bat), GTK_WIDGET(g->align[i]), i%3, i/3, 1, 1);
g_signal_connect(G_OBJECT(g->align[i]), "toggled", G_CALLBACK(alignment_callback), self);
}
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), bat, label, GTK_POS_RIGHT, 2, 1);
// x/y offset
g->x_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->xoffset, 3);
dt_bauhaus_slider_set_format(g->x_offset, "%.3f");
dt_bauhaus_widget_set_label(g->x_offset, NULL, _("x offset"));
g->y_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->yoffset, 3);
dt_bauhaus_slider_set_format(g->y_offset, "%.3f");
dt_bauhaus_widget_set_label(g->y_offset, NULL, _("y offset"));
gtk_grid_attach(GTK_GRID(self->widget), g->x_offset, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->y_offset, 0, line++, 3, 1);
// Let's add some tooltips and hook up some signals...
gtk_widget_set_tooltip_text(g->opacity, _("the opacity of the watermark"));
gtk_widget_set_tooltip_text(g->scale, _("the scale of the watermark"));
gtk_widget_set_tooltip_text(g->rotate, _("the rotation of the watermark"));
g_signal_connect(G_OBJECT(g->opacity), "value-changed", G_CALLBACK(opacity_callback), self);
g_signal_connect(G_OBJECT(g->scale), "value-changed", G_CALLBACK(scale_callback), self);
g_signal_connect(G_OBJECT(g->rotate), "value-changed", G_CALLBACK(rotate_callback), self);
g_signal_connect(G_OBJECT(g->x_offset), "value-changed", G_CALLBACK(xoffset_callback), self);
g_signal_connect(G_OBJECT(g->y_offset), "value-changed", G_CALLBACK(yoffset_callback), self);
g_signal_connect(G_OBJECT(g->refresh), "clicked", G_CALLBACK(refresh_callback), self);
refresh_watermarks(self);
g_signal_connect(G_OBJECT(g->watermarks), "value-changed", G_CALLBACK(watermark_callback), self);
g_signal_connect(G_OBJECT(g->sizeto), "value-changed", G_CALLBACK(sizeto_callback), self);
g_signal_connect(G_OBJECT(g->text), "changed", G_CALLBACK(text_callback), self);
g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self);
g_signal_connect(G_OBJECT(g->fontsel), "font-set", G_CALLBACK(fontsel_callback), self);
}
void gui_cleanup(struct dt_iop_module_t *self)
{
free(self->gui_data);
self->gui_data = NULL;
}
void gui_init(dt_lib_module_t *self)
{
self->data = calloc(1, sizeof(dt_lib_camera_t));
// Setup lib data
dt_lib_camera_t *lib = self->data;
lib->data.listener = calloc(1, sizeof(dt_camctl_listener_t));
lib->data.listener->data = lib;
lib->data.listener->camera_error = _camera_error_callback;
lib->data.listener->camera_property_value_changed = _camera_property_value_changed;
lib->data.listener->camera_property_accessibility_changed = _camera_property_accessibility_changed;
// Setup gui
lib->gui.rows = 0;
lib->gui.prop_end = 0;
self->widget = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
lib->gui.main_grid = GTK_GRID(self->widget);
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
GtkBox *hbox;
// Camera control
GtkWidget *label = dt_ui_section_label_new(_("camera control"));
gtk_grid_attach(GTK_GRID(self->widget), label, lib->gui.rows++, 0, 2, 1);
lib->gui.label1 = gtk_label_new(_("modes"));
lib->gui.label2 = gtk_label_new(_("timer (s)"));
lib->gui.label3 = gtk_label_new(_("count"));
lib->gui.label4 = gtk_label_new(_("brackets"));
lib->gui.label5 = gtk_label_new(_("bkt. steps"));
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label1), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label2), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label3), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label4), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label5), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label1), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label2), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label3), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label4), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label5), 0, lib->gui.rows++, 1, 1);
// capture modes buttons
lib->gui.tb1 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_timer, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
lib->gui.tb2 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_filmstrip, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
lib->gui.tb3 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_bracket, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb1), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb2), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb3), TRUE, TRUE, 0);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(hbox), GTK_WIDGET(lib->gui.label1), GTK_POS_RIGHT, 1, 1);
lib->gui.sb1 = gtk_spin_button_new_with_range(1, 60, 1);
lib->gui.sb2 = gtk_spin_button_new_with_range(1, 500, 1);
lib->gui.sb3 = gtk_spin_button_new_with_range(1, 5, 1);
lib->gui.sb4 = gtk_spin_button_new_with_range(1, 9, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb1), GTK_WIDGET(lib->gui.label2), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb2), GTK_WIDGET(lib->gui.label3), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb3), GTK_WIDGET(lib->gui.label4), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb4), GTK_WIDGET(lib->gui.label5), GTK_POS_RIGHT, 1, 1);
lib->gui.button1 = gtk_button_new_with_label(_("capture image(s)"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.button1), 0, lib->gui.rows++, 2, 1);
g_object_set(G_OBJECT(lib->gui.tb1), "tooltip-text", _("toggle delayed capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.tb2), "tooltip-text", _("toggle sequenced capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.tb3), "tooltip-text", _("toggle bracketed capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb1), "tooltip-text",
_("the count of seconds before actually doing a capture"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb2), "tooltip-text",
_("the amount of images to capture in a sequence,\nyou can use this in conjunction with "
"delayed mode to create stop-motion sequences."),
(char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb3), "tooltip-text",
_("the amount of brackets on each side of centered shoot, amount of images = (brackets*2)+1."),
(char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb4), "tooltip-text",
_("the amount of steps per bracket, steps is camera configurable and usually 3 steps per "
"stop\nwith other words, 3 steps is 1EV exposure step between brackets."),
(char *)NULL);
g_signal_connect(G_OBJECT(lib->gui.tb1), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb2), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb3), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.button1), "clicked", G_CALLBACK(_capture_button_clicked), lib);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb1), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb2), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb3), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb4), FALSE);
// Camera settings
label = dt_ui_section_label_new(_("properties"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 2, 1);
lib->gui.prop_start = lib->gui.rows -1;
lib->gui.prop_end = lib->gui.rows;
// user specified properties
label = dt_ui_section_label_new(_("additional properties"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 2, 1);
label = gtk_label_new(_("label"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
lib->gui.plabel = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.plabel), 0);
dt_gui_key_accel_block_on_focus_connect(lib->gui.plabel);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.plabel), GTK_WIDGET(label), GTK_POS_RIGHT, 1, 1);
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
label = gtk_label_new(_("property"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
GtkWidget *widget = gtk_button_new_with_label("O");
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_show_property_popupmenu_clicked), lib);
lib->gui.pname = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.pname), 0);
dt_gui_key_accel_block_on_focus_connect(lib->gui.pname);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.pname), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(widget), FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(hbox), GTK_WIDGET(label), GTK_POS_RIGHT, 1, 1);
widget = gtk_button_new_with_label(_("add user property"));
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_add_property_button_clicked), lib);
gtk_widget_show(widget);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(widget), 0, lib->gui.rows++, 2, 1);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_colorzones_gui_data_t));
dt_iop_colorzones_gui_data_t *c = (dt_iop_colorzones_gui_data_t *)self->gui_data;
dt_iop_colorzones_params_t *p = (dt_iop_colorzones_params_t *)self->params;
// c->channel = DT_IOP_COLORZONES_C;
c->channel = dt_conf_get_int("plugins/darkroom/colorzones/gui_channel");
int ch = (int)c->channel;
c->minmax_curve = dt_draw_curve_new(0.0, 1.0, CATMULL_ROM);
(void)dt_draw_curve_add_point(c->minmax_curve, p->equalizer_x[ch][DT_IOP_COLORZONES_BANDS-2]-1.0, p->equalizer_y[ch][DT_IOP_COLORZONES_BANDS-2]);
for(int k=0; k<DT_IOP_COLORZONES_BANDS; k++) (void)dt_draw_curve_add_point(c->minmax_curve, p->equalizer_x[ch][k], p->equalizer_y[ch][k]);
(void)dt_draw_curve_add_point(c->minmax_curve, p->equalizer_x[ch][1]+1.0, p->equalizer_y[ch][1]);
c->mouse_x = c->mouse_y = c->mouse_pick = -1.0;
c->dragging = 0;
c->x_move = -1;
c->mouse_radius = 1.0/DT_IOP_COLORZONES_BANDS;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
// select by which dimension
GtkHBox *hbox = GTK_HBOX(gtk_hbox_new(FALSE, 5));
GtkWidget *label = gtk_label_new(_("select by"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
c->select_by = gtk_combo_box_new_text();
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_combo_box_append_text(GTK_COMBO_BOX(c->select_by), _("hue"));
gtk_combo_box_append_text(GTK_COMBO_BOX(c->select_by), _("saturation"));
gtk_combo_box_append_text(GTK_COMBO_BOX(c->select_by), _("lightness"));
gtk_box_pack_start(GTK_BOX(hbox), c->select_by, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (c->select_by), "changed", G_CALLBACK (select_by_changed), (gpointer)self);
GtkWidget *tb = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(tb), "tooltip-text", _("pick gui color from image"), (char *)NULL);
g_signal_connect(G_OBJECT(tb), "toggled", G_CALLBACK(request_pick_toggled), self);
gtk_box_pack_start(GTK_BOX(hbox), tb, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), FALSE, FALSE, 0);
// tabs
GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));//DT_GUI_IOP_MODULE_CONTROL_SPACING));
c->channel_tabs = GTK_NOTEBOOK(gtk_notebook_new());
gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_("lightness")));
gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_("saturation")));
gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_("hue")));
gtk_widget_show_all(GTK_WIDGET(gtk_notebook_get_nth_page(c->channel_tabs, c->channel)));
gtk_notebook_set_current_page(GTK_NOTEBOOK(c->channel_tabs), c->channel);
g_object_set(G_OBJECT(c->channel_tabs), "homogeneous", TRUE, (char *)NULL);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(c->channel_tabs), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(c->channel_tabs), "switch_page",
G_CALLBACK (colorzones_tab_switch), self);
// the nice graph
c->area = GTK_DRAWING_AREA(gtk_drawing_area_new());
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(c->area), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(vbox), TRUE, TRUE, 5);
gtk_drawing_area_size(c->area, 195, 195);
gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK);
g_signal_connect (G_OBJECT (c->area), "expose-event",
G_CALLBACK (colorzones_expose), self);
g_signal_connect (G_OBJECT (c->area), "button-press-event",
G_CALLBACK (colorzones_button_press), self);
g_signal_connect (G_OBJECT (c->area), "button-release-event",
G_CALLBACK (colorzones_button_release), self);
g_signal_connect (G_OBJECT (c->area), "motion-notify-event",
G_CALLBACK (colorzones_motion_notify), self);
g_signal_connect (G_OBJECT (c->area), "leave-notify-event",
G_CALLBACK (colorzones_leave_notify), self);
g_signal_connect (G_OBJECT (c->area), "enter-notify-event",
G_CALLBACK (colorzones_enter_notify), self);
g_signal_connect (G_OBJECT (c->area), "scroll-event",
G_CALLBACK (colorzones_scrolled), self);
c->hsRGB = dt_colorspaces_create_srgb_profile();
c->hLab = dt_colorspaces_create_lab_profile();
c->xform = cmsCreateTransform(c->hLab, TYPE_Lab_DBL, c->hsRGB, TYPE_RGB_DBL,
INTENT_PERCEPTUAL, 0);
}
void gui_init(dt_lib_module_t *self)
{
self->data = calloc(1, sizeof(dt_lib_live_view_t));
// Setup lib data
dt_lib_live_view_t *lib = self->data;
lib->splitline_x = lib->splitline_y = 0.5;
// Setup gui
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
dt_gui_add_help_link(self->widget, "live_view.html#live_view");
GtkWidget *box;
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
lib->live_view = dtgtk_togglebutton_new(dtgtk_cairo_paint_eye, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
lib->live_view_zoom = dtgtk_button_new(
dtgtk_cairo_paint_zoom, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL); // TODO: see _zoom_live_view_clicked
lib->rotate_ccw = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
lib->rotate_cw = dtgtk_button_new(dtgtk_cairo_paint_refresh,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_UP, NULL);
lib->flip = dtgtk_togglebutton_new(dtgtk_cairo_paint_flip,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_UP, NULL);
gtk_box_pack_start(GTK_BOX(box), lib->live_view, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->live_view_zoom, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->rotate_ccw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->rotate_cw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->flip, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(lib->live_view, _("toggle live view"));
gtk_widget_set_tooltip_text(lib->live_view_zoom, _("zoom live view"));
gtk_widget_set_tooltip_text(lib->rotate_ccw, _("rotate 90 degrees ccw"));
gtk_widget_set_tooltip_text(lib->rotate_cw, _("rotate 90 degrees cw"));
gtk_widget_set_tooltip_text(lib->flip, _("flip live view horizontally"));
g_signal_connect(G_OBJECT(lib->live_view), "clicked", G_CALLBACK(_toggle_live_view_clicked), lib);
g_signal_connect(G_OBJECT(lib->live_view_zoom), "clicked", G_CALLBACK(_zoom_live_view_clicked), lib);
g_signal_connect(G_OBJECT(lib->rotate_ccw), "clicked", G_CALLBACK(_rotate_ccw), lib);
g_signal_connect(G_OBJECT(lib->rotate_cw), "clicked", G_CALLBACK(_rotate_cw), lib);
g_signal_connect(G_OBJECT(lib->flip), "clicked", G_CALLBACK(_toggle_flip_clicked), lib);
// focus buttons
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
lib->focus_in_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_LEFT, NULL);
lib->focus_in_small
= dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER
| CPF_DIRECTION_LEFT, NULL); // TODO icon not centered
lib->focus_out_small = dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER
| CPF_DIRECTION_RIGHT, NULL); // TODO same here
lib->focus_out_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_RIGHT, NULL);
gtk_box_pack_start(GTK_BOX(box), lib->focus_in_big, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_in_small, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_out_small, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_out_big, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(lib->focus_in_big, _("move focus point in (big steps)"));
gtk_widget_set_tooltip_text(lib->focus_in_small, _("move focus point in (small steps)"));
gtk_widget_set_tooltip_text(lib->focus_out_small, _("move focus point out (small steps)"));
gtk_widget_set_tooltip_text(lib->focus_out_big, _("move focus point out (big steps)"));
// Near 3
g_signal_connect(G_OBJECT(lib->focus_in_big), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(2));
// Near 1
g_signal_connect(G_OBJECT(lib->focus_in_small), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(0));
// Far 1
g_signal_connect(G_OBJECT(lib->focus_out_small), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(4));
// Far 3
g_signal_connect(G_OBJECT(lib->focus_out_big), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(6));
// Guides
lib->guide_selector = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->guide_selector, NULL, _("guides"));
gtk_box_pack_start(GTK_BOX(self->widget), lib->guide_selector, TRUE, TRUE, 0);
lib->guides_widgets = gtk_stack_new();
gtk_stack_set_homogeneous(GTK_STACK(lib->guides_widgets), FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), lib->guides_widgets, TRUE, TRUE, 0);
dt_bauhaus_combobox_add(lib->guide_selector, _("none"));
int i = 0;
for(GList *iter = darktable.guides; iter; iter = g_list_next(iter), i++)
{
GtkWidget *widget = NULL;
dt_guides_t *guide = (dt_guides_t *)iter->data;
dt_bauhaus_combobox_add(lib->guide_selector, _(guide->name));
if(guide->widget)
{
// generate some unique name so that we can have the same name several times
char name[5];
snprintf(name, sizeof(name), "%d", i);
widget = guide->widget(NULL, guide->user_data);
gtk_widget_show_all(widget);
gtk_stack_add_named(GTK_STACK(lib->guides_widgets), widget, name);
}
lib->guides_widgets_list = g_list_append(lib->guides_widgets_list, widget);
}
gtk_widget_set_no_show_all(lib->guides_widgets, TRUE);
gtk_widget_set_tooltip_text(lib->guide_selector, _("display guide lines to help compose your photograph"));
g_signal_connect(G_OBJECT(lib->guide_selector), "value-changed", G_CALLBACK(guides_presets_changed), lib);
lib->flip_guides = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->flip_guides, NULL, _("flip"));
dt_bauhaus_combobox_add(lib->flip_guides, _("none"));
dt_bauhaus_combobox_add(lib->flip_guides, _("horizontally"));
dt_bauhaus_combobox_add(lib->flip_guides, _("vertically"));
dt_bauhaus_combobox_add(lib->flip_guides, _("both"));
gtk_widget_set_tooltip_text(lib->flip_guides, _("flip guides"));
gtk_box_pack_start(GTK_BOX(self->widget), lib->flip_guides, TRUE, TRUE, 0);
lib->overlay = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay, NULL, _("overlay"));
dt_bauhaus_combobox_add(lib->overlay, _("none"));
dt_bauhaus_combobox_add(lib->overlay, _("selected image"));
dt_bauhaus_combobox_add(lib->overlay, _("id"));
gtk_widget_set_tooltip_text(lib->overlay, _("overlay another image over the live view"));
g_signal_connect(G_OBJECT(lib->overlay), "value-changed", G_CALLBACK(overlay_changed), lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay, TRUE, TRUE, 0);
lib->overlay_id_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *label = gtk_label_new(_("image id"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
lib->overlay_id = gtk_spin_button_new_with_range(0, 1000000000, 1);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(lib->overlay_id), 0);
gtk_widget_set_tooltip_text(lib->overlay_id, _("enter image id of the overlay manually"));
g_signal_connect(G_OBJECT(lib->overlay_id), "value-changed", G_CALLBACK(_overlay_id_changed), lib);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lib->overlay_id),
dt_conf_get_int("plugins/lighttable/live_view/overlay_imgid"));
gtk_box_pack_start(GTK_BOX(lib->overlay_id_box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(lib->overlay_id_box), lib->overlay_id, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_id_box, TRUE, TRUE, 0);
gtk_widget_show(lib->overlay_id);
gtk_widget_show(label);
lib->overlay_mode = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay_mode, NULL, _("overlay mode"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "normal"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "xor"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "add"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "saturate"));
#if(CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 10, 0))
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "multiply"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "screen"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "overlay"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "darken"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "lighten"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "color dodge"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "color burn"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "hard light"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "soft light"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "difference"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "exclusion"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL hue"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL saturation"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL color"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL luminosity"));
#endif
gtk_widget_set_tooltip_text(lib->overlay_mode, _("mode of the overlay"));
dt_bauhaus_combobox_set(lib->overlay_mode, dt_conf_get_int("plugins/lighttable/live_view/overlay_mode"));
g_signal_connect(G_OBJECT(lib->overlay_mode), "value-changed", G_CALLBACK(_overlay_mode_changed), lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_mode, TRUE, TRUE, 0);
lib->overlay_splitline = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay_splitline, NULL, _("split line"));
dt_bauhaus_combobox_add(lib->overlay_splitline, _("off"));
dt_bauhaus_combobox_add(lib->overlay_splitline, _("on"));
gtk_widget_set_tooltip_text(lib->overlay_splitline, _("only draw part of the overlay"));
dt_bauhaus_combobox_set(lib->overlay_splitline, dt_conf_get_int("plugins/lighttable/live_view/splitline"));
g_signal_connect(G_OBJECT(lib->overlay_splitline), "value-changed", G_CALLBACK(_overlay_splitline_changed),
lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_splitline, TRUE, TRUE, 0);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_mode), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_id_box), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_splitline), FALSE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_mode), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_id_box), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_splitline), TRUE);
guides_presets_set_visibility(lib, 0);
}
void
gui_init (dt_lib_module_t *self)
{
self->widget = gtk_vbox_new(FALSE, 5);
self->data = malloc(sizeof(dt_lib_camera_t));
memset(self->data,0,sizeof(dt_lib_camera_t));
// Setup lib data
dt_lib_camera_t *lib=self->data;
lib->data.listener = malloc(sizeof(dt_camctl_listener_t));
memset(lib->data.listener,0,sizeof(dt_camctl_listener_t));
lib->data.listener->data=lib;
lib->data.listener->camera_error=_camera_error_callback;
lib->data.listener->image_downloaded=_camera_tethered_downloaded_callback;
lib->data.listener->camera_property_value_changed=_camera_property_value_changed;
lib->data.listener->camera_property_accessibility_changed=_camera_property_accessibility_changed;
lib->data.listener->request_image_path=_camera_tethered_request_image_path;
lib->data.listener->request_image_filename=_camera_tethered_request_image_filename;
// Setup gui
self->widget = gtk_vbox_new(FALSE, 5);
GtkBox *hbox, *vbox1, *vbox2;
// Camera control
gtk_box_pack_start(GTK_BOX(self->widget), dtgtk_label_new(_("camera control"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT), TRUE, TRUE, 5);
vbox1 = GTK_BOX(gtk_vbox_new(TRUE, 0));
vbox2 = GTK_BOX(gtk_vbox_new(TRUE, 0));
lib->gui.label1=gtk_label_new(_("modes"));
lib->gui.label2=gtk_label_new(_("timer (s)"));
lib->gui.label3=gtk_label_new(_("count"));
lib->gui.label4=gtk_label_new(_("brackets"));
lib->gui.label5=gtk_label_new(_("bkt. steps"));
gtk_misc_set_alignment(GTK_MISC(lib->gui.label1 ), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(lib->gui.label2 ), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(lib->gui.label3 ), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(lib->gui.label4 ), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(lib->gui.label5 ), 0.0, 0.5);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label1), FALSE, FALSE, 0);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label2), FALSE, FALSE, 0);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label3), FALSE, FALSE, 0);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label4), FALSE, FALSE, 0);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label5), FALSE, FALSE, 0);
// capture modes buttons
lib->gui.tb1=DTGTK_TOGGLEBUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_timer,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
lib->gui.tb2=DTGTK_TOGGLEBUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_filmstrip,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
lib->gui.tb3=DTGTK_TOGGLEBUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_bracket,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb1), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb2), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb3), TRUE, TRUE, 0);
gtk_box_pack_start(vbox2, GTK_WIDGET(hbox),FALSE, FALSE, 0);
lib->gui.sb1=gtk_spin_button_new_with_range(1,60,1);
lib->gui.sb2=gtk_spin_button_new_with_range(1,500,1);
lib->gui.sb3=gtk_spin_button_new_with_range(1,5,1);
lib->gui.sb4=gtk_spin_button_new_with_range(1,9,1);
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.sb1), TRUE, TRUE, 0);
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.sb2), TRUE, TRUE, 0);
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.sb3), TRUE, TRUE, 0);
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.sb4), TRUE, TRUE, 0);
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox2), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), FALSE, FALSE, 5);
lib->gui.button1=gtk_button_new_with_label(_("capture image(s)"));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(lib->gui.button1), FALSE, FALSE, 5);
g_object_set(G_OBJECT(lib->gui.tb1), "tooltip-text", _("toggle delayed capture mode"), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.tb2), "tooltip-text", _("toggle sequenced capture mode"), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.tb3), "tooltip-text", _("toggle bracketed capture mode"), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.sb1), "tooltip-text", _("the count of seconds before actually doing a capture"), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.sb2), "tooltip-text", _("the amount of images to capture in a sequence,\nyou can use this in conjuction with delayed mode to create stop-motion sequences."), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.sb3), "tooltip-text", _("the amount of brackets on each side of centered shoot, amount of images = (brackets*2)+1."), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.sb4), "tooltip-text", _("the amount of steps per bracket, steps is camera configurable and usally 3 steps per stop\nwith other words, 3 steps is 1EV exposure step between brackets."), (char *)NULL);
g_signal_connect(G_OBJECT(lib->gui.tb1), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb2), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb3), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.button1), "clicked", G_CALLBACK(_capture_button_clicked), lib);
gtk_widget_set_sensitive( GTK_WIDGET(lib->gui.sb1),FALSE);
gtk_widget_set_sensitive( GTK_WIDGET(lib->gui.sb2),FALSE);
gtk_widget_set_sensitive( GTK_WIDGET(lib->gui.sb3),FALSE);
gtk_widget_set_sensitive( GTK_WIDGET(lib->gui.sb4),FALSE);
// Camera settings
dt_lib_camera_property_t *prop;
gtk_box_pack_start(GTK_BOX(self->widget), dtgtk_label_new(_("properties"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT), TRUE, TRUE, 0);
lib->gui.pvbox1 = GTK_BOX(gtk_vbox_new(TRUE, 0));
lib->gui.pvbox2 = GTK_BOX(gtk_vbox_new(TRUE, 0));
if( (prop=_lib_property_add_new(lib, _("program"),"expprogram"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("focus mode"),"focusmode"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
else if( (prop=_lib_property_add_new(lib, _("focus mode"),"drivemode"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("aperture"),"f-number"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
else if( (prop=_lib_property_add_new(lib, _("aperture"),"aperture"))!=NULL ) // for Canon cameras
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("focal length"),"focallength"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("shutterspeed2"),"shutterspeed2"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
else if( (prop=_lib_property_add_new(lib, _("shutterspeed"),"shutterspeed"))!=NULL ) // Canon, again
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("iso"),"iso"))!=NULL)
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("wb"),"whitebalance"))!=NULL)
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("quality"),"imagequality"))!=NULL)
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("size"),"imagesize"))!=NULL)
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
/* add user widgets */
GSList *options = dt_conf_all_string_entries ("plugins/capture/tethering/properties");
if (options)
{
GSList *item = options;
if (item)
{
do
{
dt_conf_string_entry_t *entry = (dt_conf_string_entry_t *)item->data;
/* get the label from key */
char *p=entry->key;
while (p++<entry->key+strlen(entry->key)) if (*p=='_') *p=' ';
if ((prop = _lib_property_add_new (lib, entry->key,entry->value )) != NULL)
{
hbox = GTK_BOX (gtk_hbox_new(FALSE, 0));
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (prop->values), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start (lib->gui.pvbox1, GTK_WIDGET (prop->label), TRUE, TRUE, 0);
gtk_box_pack_start (lib->gui.pvbox2, GTK_WIDGET (hbox), TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (prop->osd), "clicked", G_CALLBACK (_osd_button_clicked), prop);
}
}
while ( (item = g_slist_next (item)) != NULL );
}
}
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(lib->gui.pvbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(lib->gui.pvbox2), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), FALSE, FALSE, 5);
/* build the propertymenu */
dt_camctl_camera_build_property_menu (darktable.camctl,NULL,&lib->gui.properties_menu,G_CALLBACK(_property_choice_callback),lib);
// user specified properties
gtk_box_pack_start (GTK_BOX (self->widget), dtgtk_label_new (_("additional properties"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT), TRUE, TRUE, 5);
vbox1 = GTK_BOX (gtk_vbox_new (TRUE, 0));
vbox2 = GTK_BOX (gtk_vbox_new (TRUE, 0));
gtk_box_pack_start (vbox1, GTK_WIDGET ( gtk_label_new (_("label"))), TRUE, TRUE, 0);
lib->gui.plabel = gtk_entry_new ();
dt_gui_key_accel_block_on_focus (lib->gui.plabel);
gtk_box_pack_start (vbox2, GTK_WIDGET ( lib->gui.plabel ), TRUE, TRUE, 0);
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start (vbox1, GTK_WIDGET ( gtk_label_new (_("property"))), TRUE, TRUE, 0);
GtkWidget *widget = gtk_button_new_with_label("O");
g_signal_connect (G_OBJECT (widget), "clicked", G_CALLBACK (_show_property_popupmenu_clicked), lib);
lib->gui.pname = gtk_entry_new ();
dt_gui_key_accel_block_on_focus (lib->gui.pname);
gtk_box_pack_start (hbox, GTK_WIDGET ( lib->gui.pname ), TRUE, TRUE, 0);
gtk_box_pack_start (hbox, GTK_WIDGET ( widget ), FALSE, FALSE, 0);
gtk_box_pack_start (vbox2, GTK_WIDGET ( hbox ), TRUE, TRUE, 0);
hbox = GTK_BOX (gtk_hbox_new(FALSE, 0));
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (vbox1), FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (vbox2), TRUE, TRUE, 5);
widget = gtk_button_new_with_label (_("add user property"));
g_signal_connect (G_OBJECT (widget), "clicked", G_CALLBACK (_add_property_button_clicked), lib);
gtk_widget_show(widget);
gtk_box_pack_start (GTK_BOX (self->widget), GTK_WIDGET(hbox), FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (self->widget), GTK_WIDGET (widget), TRUE, TRUE, 5);
// Get camera model name
lib->data.camera_model=dt_camctl_camera_get_model(darktable.camctl,NULL);
// Register listener
dt_camctl_register_listener(darktable.camctl,lib->data.listener);
dt_camctl_tether_mode(darktable.camctl,NULL,TRUE);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_borders_gui_data_t));
dt_iop_borders_gui_data_t *g = (dt_iop_borders_gui_data_t *)self->gui_data;
dt_iop_borders_params_t *p = (dt_iop_borders_params_t *)self->params;
self->widget = gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE);
g->size = dt_bauhaus_slider_new_with_range(self, 0.0, 50.0, 0.5, p->size*100.0, 2);
dt_bauhaus_widget_set_label(g->size, _("border size"));
dt_bauhaus_slider_set_format(g->size, "%.2f%%");
g_signal_connect (G_OBJECT (g->size), "value-changed", G_CALLBACK (size_callback), self);
g_object_set(G_OBJECT(g->size), "tooltip-text", _("size of the border in percent of the full image"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), g->size, TRUE, TRUE, 0);
g->aspect = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->aspect, 1);
dt_bauhaus_widget_set_label(g->aspect, _("aspect"));
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect, TRUE, TRUE, 0);
dt_bauhaus_combobox_add(g->aspect, _("image"));
dt_bauhaus_combobox_add(g->aspect, _("golden cut"));
dt_bauhaus_combobox_add(g->aspect, _("1:2"));
dt_bauhaus_combobox_add(g->aspect, _("3:2"));
dt_bauhaus_combobox_add(g->aspect, _("4:3"));
dt_bauhaus_combobox_add(g->aspect, _("square"));
dt_bauhaus_combobox_add(g->aspect, _("DIN"));
dt_bauhaus_combobox_add(g->aspect, _("16:9"));
dt_bauhaus_combobox_add(g->aspect, _("constant border"));
g_signal_connect (G_OBJECT (g->aspect), "value-changed", G_CALLBACK (aspect_changed), self);
g_object_set(G_OBJECT(g->aspect), "tooltip-text", _("select the aspect ratio or right click and type your own (w:h)"), (char *)NULL);
GtkWidget *box = gtk_hbox_new(FALSE, 0);
g->colorpick = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color, CPF_IGNORE_FG_STATE | CPF_STYLE_FLAT));
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), 24, 24);
GtkWidget *label = dtgtk_reset_label_new (_("frame color"), self, &p->color, 3*sizeof(float));
g_signal_connect (G_OBJECT (g->colorpick), "clicked", G_CALLBACK (colorpick_callback), self);
GtkWidget *tb = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(tb), "tooltip-text", _("pick gui color from image"), (char *)NULL);
gtk_widget_set_size_request(tb, 24, 24);
g_signal_connect(G_OBJECT(tb), "toggled", G_CALLBACK(request_pick_toggled), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), tb, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
g->aspect_ratios[0] = self->dev->image_storage.width/(float)self->dev->image_storage.height;
if(g->aspect_ratios[0] < 1.0f)
g->aspect_ratios[0] = 1.0f / g->aspect_ratios[0];
g->aspect_ratios[1] = PHI;
g->aspect_ratios[2] = 2.0f/1.0f;
g->aspect_ratios[3] = 3.0f/2.0f;
g->aspect_ratios[4] = 4.0f/3.0f;
g->aspect_ratios[5] = 1.0f;
g->aspect_ratios[6] = sqrtf(2.0f);
g->aspect_ratios[7] = 16.0f/9.0f;
g->aspect_ratios[8] = -1.0f;
g_signal_connect (G_OBJECT(self->widget), "expose-event", G_CALLBACK(expose), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_tonecurve_gui_data_t));
dt_iop_tonecurve_gui_data_t *c = (dt_iop_tonecurve_gui_data_t *)self->gui_data;
dt_iop_tonecurve_params_t *p = (dt_iop_tonecurve_params_t *)self->params;
for (int ch=0; ch<ch_max; ch++)
{
c->minmax_curve[ch] = dt_draw_curve_new(0.0, 1.0, p->tonecurve_type[ch]);
c->minmax_curve_nodes[ch] = p->tonecurve_nodes[ch];
c->minmax_curve_type[ch] = p->tonecurve_type[ch];
for(int k=0; k<p->tonecurve_nodes[ch]; k++)
(void)dt_draw_curve_add_point(c->minmax_curve[ch], p->tonecurve[ch][k].x, p->tonecurve[ch][k].y);
}
c->channel = ch_L;
c->mouse_x = c->mouse_y = -1.0;
c->selected = -1;
self->widget = gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE);
// tabs
c->channel_tabs = GTK_NOTEBOOK(gtk_notebook_new());
gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_(" L ")));
g_object_set(G_OBJECT(gtk_notebook_get_tab_label(c->channel_tabs, gtk_notebook_get_nth_page(c->channel_tabs, -1))), "tooltip-text", _("tonecurve for L channel"), NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_(" a ")));
g_object_set(G_OBJECT(gtk_notebook_get_tab_label(c->channel_tabs, gtk_notebook_get_nth_page(c->channel_tabs, -1))), "tooltip-text", _("tonecurve for a channel"), NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(c->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(_(" b ")));
g_object_set(G_OBJECT(gtk_notebook_get_tab_label(c->channel_tabs, gtk_notebook_get_nth_page(c->channel_tabs, -1))), "tooltip-text", _("tonecurve for b channel"), NULL);
gtk_widget_show_all(GTK_WIDGET(gtk_notebook_get_nth_page(c->channel_tabs, c->channel)));
gtk_notebook_set_current_page(GTK_NOTEBOOK(c->channel_tabs), c->channel);
g_object_set(G_OBJECT(c->channel_tabs), "homogeneous", TRUE, (char *)NULL);
GtkWidget *tb = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(tb), "tooltip-text", _("pick gui color from image"), (char *)NULL);
GtkWidget *notebook = gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(notebook), GTK_WIDGET(c->channel_tabs), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(notebook), GTK_WIDGET(tb), FALSE, FALSE, 0);
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), vbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(notebook), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(c->channel_tabs), "switch_page",
G_CALLBACK (tab_switch), self);
c->area = GTK_DRAWING_AREA(gtk_drawing_area_new());
//GtkWidget *asp = gtk_aspect_frame_new(NULL, 0.5, 0.5, 1.0, FALSE);//TRUE);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(c->area), TRUE, TRUE, 0);
// gtk_box_pack_start(GTK_BOX(vbox), asp, TRUE, TRUE, 0);
// gtk_container_add(GTK_CONTAINER(asp), GTK_WIDGET(c->area));
gtk_drawing_area_size(c->area, 0, 258);
g_object_set (GTK_OBJECT(c->area), "tooltip-text", _("double click to reset curve"), (char *)NULL);
gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK);
g_signal_connect (G_OBJECT (c->area), "expose-event",
G_CALLBACK (dt_iop_tonecurve_expose), self);
g_signal_connect (G_OBJECT (c->area), "button-press-event",
G_CALLBACK (dt_iop_tonecurve_button_press), self);
g_signal_connect (G_OBJECT (c->area), "motion-notify-event",
G_CALLBACK (dt_iop_tonecurve_motion_notify), self);
g_signal_connect (G_OBJECT (c->area), "leave-notify-event",
G_CALLBACK (dt_iop_tonecurve_leave_notify), self);
g_signal_connect (G_OBJECT (c->area), "enter-notify-event",
G_CALLBACK (dt_iop_tonecurve_enter_notify), self);
g_signal_connect (G_OBJECT (c->area), "configure-event",
G_CALLBACK (area_resized), self);
g_signal_connect (G_OBJECT(tb), "toggled",
G_CALLBACK (pick_toggled), self);
g_signal_connect (G_OBJECT (c->area), "scroll-event",
G_CALLBACK (scrolled), self);
c->autoscale_ab = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(c->autoscale_ab, _("scale chroma"));
dt_bauhaus_combobox_add(c->autoscale_ab, _("auto"));
dt_bauhaus_combobox_add(c->autoscale_ab, _("manual"));
gtk_box_pack_start(GTK_BOX(self->widget), c->autoscale_ab, TRUE, TRUE, 0);
g_object_set (GTK_OBJECT(c->autoscale_ab), "tooltip-text", _("if set to auto, a and b curves have no effect and are not displayed. chroma values (a and b) of each pixel are then adjusted based on L curve data."), (char *)NULL);
g_signal_connect(G_OBJECT(c->autoscale_ab), "value-changed", G_CALLBACK(autoscale_ab_callback), self);
c->sizegroup = GTK_SIZE_GROUP(gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL));
gtk_size_group_add_widget(c->sizegroup, GTK_WIDGET(c->area));
gtk_size_group_add_widget(c->sizegroup, GTK_WIDGET(c->channel_tabs));
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_tool_filter_t *d = (dt_lib_tool_filter_t *)g_malloc0(sizeof(dt_lib_tool_filter_t));
self->data = (void *)d;
self->widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
/**/
GtkWidget *widget;
/* list label */
widget = gtk_label_new(_("view"));
gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 4);
d->comparator = widget = gtk_toggle_button_new_with_label(comparators[dt_collection_get_rating_comparator(darktable.collection)]);
gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 4);
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(_lib_filter_compare_button_changed),
(gpointer)self);
/* create the filter combobox */
d->filter = widget = gtk_combo_box_text_new();
gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 0);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("all"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("unstarred only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "★");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "★ ★");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "★ ★ ★");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "★ ★ ★ ★");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "★ ★ ★ ★ ★");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("rejected only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("all except rejected"));
/* select the last selected value */
gtk_combo_box_set_active(GTK_COMBO_BOX(widget), dt_collection_get_rating(darktable.collection));
g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(_lib_filter_combobox_changed), (gpointer)self);
/* sort by label */
widget = gtk_label_new(_("sort by"));
gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 4);
/* sort combobox */
d->sort = widget = gtk_combo_box_text_new();
gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 0);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("filename"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("time"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("rating"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("id"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), _("color label"));
/* select the last selected value */
gtk_combo_box_set_active(GTK_COMBO_BOX(widget), dt_collection_get_sort_field(darktable.collection));
g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(_lib_filter_sort_combobox_changed), (gpointer)self);
/* reverse order checkbutton */
d->reverse = widget
= dtgtk_togglebutton_new(dtgtk_cairo_paint_solid_arrow, CPF_DO_NOT_USE_BORDER | CPF_STYLE_BOX | CPF_DIRECTION_UP);
if(darktable.collection->params.descending)
dtgtk_togglebutton_set_paint(DTGTK_TOGGLEBUTTON(widget), dtgtk_cairo_paint_solid_arrow,
CPF_DO_NOT_USE_BORDER | CPF_STYLE_BOX | CPF_DIRECTION_DOWN);
gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 0);
/* select the last value and connect callback */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),
dt_collection_get_sort_descending(darktable.collection));
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(_lib_filter_reverse_button_changed),
(gpointer)self);
/* initialize proxy */
darktable.view_manager->proxy.filter.module = self;
darktable.view_manager->proxy.filter.reset_filter = _lib_filter_reset;
g_signal_connect_swapped(G_OBJECT(d->comparator), "map",
G_CALLBACK(_lib_filter_sync_combobox_and_comparator), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_watermark_gui_data_t));
dt_iop_watermark_gui_data_t *g = (dt_iop_watermark_gui_data_t *)self->gui_data;
dt_iop_watermark_params_t *p = (dt_iop_watermark_params_t *)self->params;
self->widget = gtk_hbox_new(FALSE,0);
GtkWidget *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);
GtkWidget *label1 = dtgtk_reset_label_new(_("marker"), self, &p->filename, sizeof(char)*64);
GtkWidget *label4 = dtgtk_reset_label_new(_("alignment"), self, &p->alignment, sizeof(int));
// Add the marker combobox
GtkWidget *hbox= gtk_hbox_new(FALSE,0);
g->combobox1 = GTK_COMBO_BOX(gtk_combo_box_new_text());
g->dtbutton1 = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
gtk_box_pack_start(GTK_BOX(hbox),GTK_WIDGET(label1),TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(hbox),GTK_WIDGET(g->combobox1),TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(hbox),GTK_WIDGET(g->dtbutton1),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox), TRUE, TRUE, 0);
// Add opacity/scale sliders to table
g->scale1 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->opacity, 0.5);
dt_bauhaus_slider_set_format(g->scale1, "%.f%%");
dt_bauhaus_widget_set_label(g->scale1,_("opacity"));
g->scale2 = dt_bauhaus_slider_new_with_range(self, 1.0, 100.0, 1.0, p->scale, 0.5);
dt_bauhaus_slider_set_format(g->scale2, "%.f%%");
dt_bauhaus_widget_set_label(g->scale2,_("scale"));
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
// Create the 3x3 gtk table toggle button table...
GtkTable *bat = GTK_TABLE( gtk_table_new(3,3,TRUE));
for(int i=0; i<9; i++)
{
g->dtba[i] = DTGTK_TOGGLEBUTTON (dtgtk_togglebutton_new (dtgtk_cairo_paint_alignment,CPF_STYLE_FLAT|(CPF_SPECIAL_FLAG<<(i+1))));
gtk_widget_set_size_request (GTK_WIDGET (g->dtba[i]),16,16);
gtk_table_attach (GTK_TABLE (bat), GTK_WIDGET (g->dtba[i]), (i%3),(i%3)+1,(i/3),(i/3)+1,0,0,0,0);
g_signal_connect (G_OBJECT (g->dtba[i]), "toggled",G_CALLBACK (alignment_callback), self);
}
GtkWidget *hbox2 = gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(hbox2),GTK_WIDGET(label4),TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(hbox2), GTK_WIDGET(bat), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox2), TRUE, TRUE, 0);
// x/y offset
g->scale3 = dt_bauhaus_slider_new_with_range(self, -0.1, 0.1,0.001, p->xoffset, 3);
dt_bauhaus_slider_set_format(g->scale3, "%.3f");
dt_bauhaus_widget_set_label(g->scale3,_("x offset"));
g->scale4 = dt_bauhaus_slider_new_with_range(self, -0.1, 0.1,0.001, p->yoffset, 3);
dt_bauhaus_slider_set_format(g->scale4, "%.3f");
dt_bauhaus_widget_set_label(g->scale4,_("y offset"));
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->scale3), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->scale4), TRUE, TRUE, 0);
// Let's add some tooltips and hook up some signals...
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the opacity of the watermark"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("the scale of the watermark"), (char *)NULL);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (opacity_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 (xoffset_callback), self);
g_signal_connect (G_OBJECT (g->scale4), "value-changed",
G_CALLBACK (yoffset_callback), self);
g_signal_connect (G_OBJECT (g->dtbutton1), "clicked",G_CALLBACK (refresh_callback), self);
refresh_watermarks( self );
g_signal_connect (G_OBJECT (g->combobox1), "changed",
G_CALLBACK (watermark_callback), self);
}
void gui_init(dt_lib_module_t *self)
{
self->data = calloc(1, sizeof(dt_lib_camera_t));
// Setup lib data
dt_lib_camera_t *lib = self->data;
lib->data.listener = calloc(1, sizeof(dt_camctl_listener_t));
lib->data.listener->data = lib;
lib->data.listener->camera_error = _camera_error_callback;
lib->data.listener->camera_property_value_changed = _camera_property_value_changed;
lib->data.listener->camera_property_accessibility_changed = _camera_property_accessibility_changed;
// Setup gui
lib->gui.rows = 0;
lib->gui.prop_end = 0;
self->widget = gtk_grid_new();
lib->gui.main_grid = GTK_GRID(self->widget);
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
GtkBox *hbox/*, *vbox1, *vbox2*/;
// Camera control
GtkWidget *label = dt_ui_section_label_new(_("camera control"));
gtk_grid_attach(GTK_GRID(self->widget), label, lib->gui.rows++, 0, 2, 1);
lib->gui.label1 = gtk_label_new(_("modes"));
lib->gui.label2 = gtk_label_new(_("timer (s)"));
lib->gui.label3 = gtk_label_new(_("count"));
lib->gui.label4 = gtk_label_new(_("brackets"));
lib->gui.label5 = gtk_label_new(_("bkt. steps"));
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label1), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label2), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label3), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label4), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label5), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label1), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label2), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label3), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label4), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label5), 0, lib->gui.rows++, 1, 1);
// capture modes buttons
lib->gui.tb1 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_timer, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
lib->gui.tb2 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_filmstrip, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
lib->gui.tb3 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_bracket, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb1), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb2), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb3), TRUE, TRUE, 0);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(hbox), GTK_WIDGET(lib->gui.label1), GTK_POS_RIGHT, 1, 1);
lib->gui.sb1 = gtk_spin_button_new_with_range(1, 60, 1);
lib->gui.sb2 = gtk_spin_button_new_with_range(1, 500, 1);
lib->gui.sb3 = gtk_spin_button_new_with_range(1, 5, 1);
lib->gui.sb4 = gtk_spin_button_new_with_range(1, 9, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb1), GTK_WIDGET(lib->gui.label2), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb2), GTK_WIDGET(lib->gui.label3), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb3), GTK_WIDGET(lib->gui.label4), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb4), GTK_WIDGET(lib->gui.label5), GTK_POS_RIGHT, 1, 1);
lib->gui.button1 = gtk_button_new_with_label(_("capture image(s)"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.button1), 0, lib->gui.rows++, 2, 1);
g_object_set(G_OBJECT(lib->gui.tb1), "tooltip-text", _("toggle delayed capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.tb2), "tooltip-text", _("toggle sequenced capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.tb3), "tooltip-text", _("toggle bracketed capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb1), "tooltip-text",
_("the count of seconds before actually doing a capture"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb2), "tooltip-text",
_("the amount of images to capture in a sequence,\nyou can use this in conjunction with "
"delayed mode to create stop-motion sequences."),
(char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb3), "tooltip-text",
_("the amount of brackets on each side of centered shoot, amount of images = (brackets*2)+1."),
(char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb4), "tooltip-text",
_("the amount of steps per bracket, steps is camera configurable and usually 3 steps per "
"stop\nwith other words, 3 steps is 1EV exposure step between brackets."),
(char *)NULL);
g_signal_connect(G_OBJECT(lib->gui.tb1), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb2), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb3), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.button1), "clicked", G_CALLBACK(_capture_button_clicked), lib);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb1), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb2), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb3), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb4), FALSE);
// Camera settings
dt_lib_camera_property_t *prop;
label = dt_ui_section_label_new(_("properties"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 2, 1);
lib->gui.prop_end = lib->gui.rows;
if((prop = _lib_property_add_new(lib, _("program"), "expprogram")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("focus mode"), "focusmode")) != NULL)
_lib_property_add_to_gui(prop, lib);
else if((prop = _lib_property_add_new(lib, _("focus mode"), "drivemode")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("aperture"), "f-number")) != NULL)
_lib_property_add_to_gui(prop, lib);
else if((prop = _lib_property_add_new(lib, _("aperture"), "aperture")) != NULL) // for Canon cameras
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("focal length"), "focallength")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("shutterspeed2"), "shutterspeed2")) != NULL)
_lib_property_add_to_gui(prop, lib);
else if((prop = _lib_property_add_new(lib, _("shutterspeed"), "shutterspeed")) != NULL) // Canon, again
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("ISO"), "iso")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("WB"), "whitebalance")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("quality"), "imagequality")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("size"), "imagesize")) != NULL)
_lib_property_add_to_gui(prop, lib);
/* add user widgets */
GSList *options = dt_conf_all_string_entries("plugins/capture/tethering/properties");
if(options)
{
GSList *item = options;
if(item)
{
do
{
dt_conf_string_entry_t *entry = (dt_conf_string_entry_t *)item->data;
/* get the label from key */
char *p = entry->key;
const char *end = entry->key + strlen(entry->key);
while(p++ < end)
if(*p == '_') *p = ' ';
if((prop = _lib_property_add_new(lib, entry->key, entry->value)) != NULL)
_lib_property_add_to_gui(prop, lib);
} while((item = g_slist_next(item)) != NULL);
}
}
/* build the propertymenu */
dt_camctl_camera_build_property_menu(darktable.camctl, NULL, &lib->gui.properties_menu,
G_CALLBACK(_property_choice_callback), lib);
// user specified properties
label = dt_ui_section_label_new(_("additional properties"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 2, 1);
label = gtk_label_new(_("label"));
lib->gui.plabel = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.plabel), 0);
dt_gui_key_accel_block_on_focus_connect(lib->gui.plabel);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.plabel), GTK_WIDGET(label), GTK_POS_RIGHT, 1, 1);
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
label = gtk_label_new(_("property"));
GtkWidget *widget = gtk_button_new_with_label("O");
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_show_property_popupmenu_clicked), lib);
lib->gui.pname = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.pname), 0);
dt_gui_key_accel_block_on_focus_connect(lib->gui.pname);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.pname), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(widget), FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(hbox), GTK_WIDGET(label), GTK_POS_RIGHT, 1, 1);
widget = gtk_button_new_with_label(_("add user property"));
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_add_property_button_clicked), lib);
gtk_widget_show(widget);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(widget), 0, lib->gui.rows++, 2, 1);
// Get camera model name
lib->data.camera_model = dt_camctl_camera_get_model(darktable.camctl, NULL);
// Register listener
dt_camctl_register_listener(darktable.camctl, lib->data.listener);
dt_camctl_tether_mode(darktable.camctl, NULL, TRUE);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_borders_gui_data_t));
dt_iop_borders_gui_data_t *g = (dt_iop_borders_gui_data_t *)self->gui_data;
dt_iop_borders_params_t *p = (dt_iop_borders_params_t *)self->params;
self->widget = gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE);
g->size = dt_bauhaus_slider_new_with_range(self, 0.0, 50.0, 0.5, p->size*100.0, 2);
dt_bauhaus_widget_set_label(g->size, NULL, _("border size"));
dt_bauhaus_slider_set_format(g->size, "%.2f%%");
g_signal_connect (G_OBJECT (g->size), "value-changed", G_CALLBACK (size_callback), self);
g_object_set(G_OBJECT(g->size), "tooltip-text", _("size of the border in percent of the full image"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), g->size, TRUE, TRUE, 0);
g->aspect = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->aspect, 1);
dt_bauhaus_widget_set_label(g->aspect, NULL, _("aspect"));
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect, TRUE, TRUE, 0);
gui_init_aspect(self);
g_signal_connect (G_OBJECT (g->aspect), "value-changed", G_CALLBACK (aspect_changed), self);
g_object_set(G_OBJECT(g->aspect), "tooltip-text", _("select the aspect ratio or right click and type your own (w:h)"), (char *)NULL);
g->aspect_orient = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->aspect_orient, NULL, _("orientation"));
dt_bauhaus_combobox_add(g->aspect_orient, _("auto"));
dt_bauhaus_combobox_add(g->aspect_orient, _("portrait"));
dt_bauhaus_combobox_add(g->aspect_orient, _("landscape"));
g_object_set(G_OBJECT(g->aspect_orient), "tooltip-text", _("aspect ratio orientation of the image with border"), (char *)NULL);
g_signal_connect (G_OBJECT (g->aspect_orient), "value-changed", G_CALLBACK (aspect_orient_changed), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect_orient, TRUE, TRUE, 0);
g->pos_h = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->pos_h, 1);
dt_bauhaus_widget_set_label(g->pos_h, NULL, _("horizontal position"));
gtk_box_pack_start(GTK_BOX(self->widget), g->pos_h, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (g->pos_h), "value-changed", G_CALLBACK (position_h_changed), self);
g_object_set(G_OBJECT(g->pos_h), "tooltip-text", _("select the horizontal position ratio relative to top or right click and type your own (y:h)"), (char *)NULL);
g->pos_v = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->pos_v, 1);
dt_bauhaus_widget_set_label(g->pos_v, NULL, _("vertical position"));
gtk_box_pack_start(GTK_BOX(self->widget), g->pos_v, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (g->pos_v), "value-changed", G_CALLBACK (position_v_changed), self);
g_object_set(G_OBJECT(g->pos_v), "tooltip-text", _("select the vertical position ratio relative to left or right click and type your own (x:w)"), (char *)NULL);
gui_init_positions(self);
g->frame_size = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_size*100.0, 2);
dt_bauhaus_widget_set_label(g->frame_size, NULL, _("frame line size"));
dt_bauhaus_slider_set_format(g->frame_size, "%.2f%%");
g_signal_connect (G_OBJECT (g->frame_size), "value-changed", G_CALLBACK (frame_size_callback), self);
g_object_set(G_OBJECT(g->frame_size), "tooltip-text", _("size of the frame line in percent of min border width"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), g->frame_size, TRUE, TRUE, 0);
g->frame_offset = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_offset*100.0, 2);
dt_bauhaus_widget_set_label(g->frame_offset, NULL, _("frame line offset"));
dt_bauhaus_slider_set_format(g->frame_offset, "%.2f%%");
g_signal_connect (G_OBJECT (g->frame_offset), "value-changed", G_CALLBACK (frame_offset_callback), self);
g_object_set(G_OBJECT(g->frame_offset), "tooltip-text", _("offset of the frame line beginning on picture side"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), g->frame_offset, TRUE, TRUE, 0);
GtkWidget *box = gtk_hbox_new(FALSE, 0);
g->colorpick = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color, CPF_IGNORE_FG_STATE | CPF_STYLE_FLAT));
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), 24, 24);
GtkWidget *label = dtgtk_reset_label_new (_("border color"), self, &p->color, 3*sizeof(float));
g_signal_connect (G_OBJECT (g->colorpick), "clicked", G_CALLBACK (colorpick_callback), self);
g->border_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
g_object_set(G_OBJECT(g->border_picker), "tooltip-text", _("pick border color from image"), (char *)NULL);
gtk_widget_set_size_request(GTK_WIDGET(g->border_picker), 24, 24);
g_signal_connect(G_OBJECT(g->border_picker), "toggled", G_CALLBACK(request_pick_toggled_border), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->border_picker), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
box = gtk_hbox_new(FALSE, 0);
g->frame_colorpick = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color, CPF_IGNORE_FG_STATE | CPF_STYLE_FLAT));
gtk_widget_set_size_request(GTK_WIDGET(g->frame_colorpick), 24, 24);
label = dtgtk_reset_label_new (_("frame line color"), self, &p->color, 3*sizeof(float));
g_signal_connect (G_OBJECT (g->frame_colorpick), "clicked", G_CALLBACK (frame_colorpick_callback), self);
g->frame_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
g_object_set(G_OBJECT(g->frame_picker), "tooltip-text", _("pick frame line color from image"), (char *)NULL);
gtk_widget_set_size_request(GTK_WIDGET(g->frame_picker), 24, 24);
g_signal_connect(G_OBJECT(g->frame_picker), "toggled", G_CALLBACK(request_pick_toggled_frame), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_picker), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT(self->widget), "expose-event", G_CALLBACK(borders_expose), self);
}
void dt_iop_gui_init_blendif(GtkVBox *blendw, dt_iop_module_t *module)
{
dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t*)module->blend_data;
/* create and add blendif support if module supports it */
if (bd->blendif_support)
{
char *Lab_labels[] = { " L ", " a ", " b ", " C ", " h " };
char *Lab_tooltips[] = { _("sliders for L channel"), _("sliders for a channel"), _("sliders for b channel"), _("sliders for chroma channel (of LCh)"), _("sliders for hue channel (of LCh)") };
char *rgb_labels[] = { _(" g "), _(" R "), _(" G "), _(" B "), _(" H "), _(" S "), _(" L ") };
char *rgb_tooltips[] = { _("sliders for gray value"), _("sliders for red channel"), _("sliders for green channel"), _("sliders for blue channel"),
_("sliders for hue channel (of HSL)"), _("sliders for chroma channel (of HSL)"), _("sliders for value channel (of HSL)")
};
char *ttinput = _("adjustment based on input received by this module:\n* range defined by upper markers: blend fully\n* range defined by lower markers: do not blend at all\n* range between adjacent upper/lower markers: blend gradually");
char *ttoutput = _("adjustment based on unblended output of this module:\n* range defined by upper markers: blend fully\n* range defined by lower markers: do not blend at all\n* range between adjacent upper/lower markers: blend gradually");
bd->tab = 0;
int maxchannels = 0;
char **labels = NULL;
char **tooltips = NULL;
switch(bd->csp)
{
case iop_cs_Lab:
maxchannels = 5;
labels = Lab_labels;
tooltips = Lab_tooltips;
bd->scale_print[0] = _blendif_scale_print_L;
bd->scale_print[1] = _blendif_scale_print_ab;
bd->scale_print[2] = _blendif_scale_print_ab;
bd->scale_print[3] = _blendif_scale_print_default;
bd->scale_print[4] = _blendif_scale_print_hue;
bd->increments[0] = 1.0f/100.0f;
bd->increments[1] = 1.0f/256.0f;
bd->increments[2] = 1.0f/256.0f;
bd->increments[3] = 1.0f/100.0f;
bd->increments[4] = 1.0f/360.0f;
bd->channels[0][0] = DEVELOP_BLENDIF_L_in;
bd->channels[0][1] = DEVELOP_BLENDIF_L_out;
bd->channels[1][0] = DEVELOP_BLENDIF_A_in;
bd->channels[1][1] = DEVELOP_BLENDIF_A_out;
bd->channels[2][0] = DEVELOP_BLENDIF_B_in;
bd->channels[2][1] = DEVELOP_BLENDIF_B_out;
bd->channels[3][0] = DEVELOP_BLENDIF_C_in;
bd->channels[3][1] = DEVELOP_BLENDIF_C_out;
bd->channels[4][0] = DEVELOP_BLENDIF_h_in;
bd->channels[4][1] = DEVELOP_BLENDIF_h_out;
bd->colorstops[0] = _gradient_L;
bd->numberstops[0] = sizeof(_gradient_L)/sizeof(dt_iop_gui_blendif_colorstop_t);
bd->colorstops[1] = _gradient_a;
bd->numberstops[1] = sizeof(_gradient_a)/sizeof(dt_iop_gui_blendif_colorstop_t);
bd->colorstops[2] = _gradient_b;
bd->numberstops[2] = sizeof(_gradient_b)/sizeof(dt_iop_gui_blendif_colorstop_t);
bd->colorstops[3] = _gradient_chroma;
bd->numberstops[3] = sizeof(_gradient_chroma)/sizeof(dt_iop_gui_blendif_colorstop_t);
bd->colorstops[4] = _gradient_hue;
bd->numberstops[4] = sizeof(_gradient_hue)/sizeof(dt_iop_gui_blendif_colorstop_t);
break;
case iop_cs_rgb:
maxchannels = 7;
labels = rgb_labels;
tooltips = rgb_tooltips;
bd->scale_print[0] = _blendif_scale_print_rgb;
bd->scale_print[1] = _blendif_scale_print_rgb;
bd->scale_print[2] = _blendif_scale_print_rgb;
bd->scale_print[3] = _blendif_scale_print_rgb;
bd->scale_print[4] = _blendif_scale_print_hue;
bd->scale_print[5] = _blendif_scale_print_default;
bd->scale_print[6] = _blendif_scale_print_L;
bd->increments[0] = 1.0f/255.0f;
bd->increments[1] = 1.0f/255.0f;
bd->increments[2] = 1.0f/255.0f;
bd->increments[3] = 1.0f/255.0f;
bd->increments[4] = 1.0f/360.0f;
bd->increments[5] = 1.0f/100.0f;
bd->increments[6] = 1.0f/100.0f;
bd->channels[0][0] = DEVELOP_BLENDIF_GRAY_in;
bd->channels[0][1] = DEVELOP_BLENDIF_GRAY_out;
bd->channels[1][0] = DEVELOP_BLENDIF_RED_in;
bd->channels[1][1] = DEVELOP_BLENDIF_RED_out;
bd->channels[2][0] = DEVELOP_BLENDIF_GREEN_in;
bd->channels[2][1] = DEVELOP_BLENDIF_GREEN_out;
bd->channels[3][0] = DEVELOP_BLENDIF_BLUE_in;
bd->channels[3][1] = DEVELOP_BLENDIF_BLUE_out;
bd->channels[4][0] = DEVELOP_BLENDIF_H_in;
bd->channels[4][1] = DEVELOP_BLENDIF_H_out;
bd->channels[5][0] = DEVELOP_BLENDIF_S_in;
bd->channels[5][1] = DEVELOP_BLENDIF_S_out;
bd->channels[6][0] = DEVELOP_BLENDIF_l_in;
bd->channels[6][1] = DEVELOP_BLENDIF_l_out;
bd->colorstops[0] = _gradient_gray;
bd->numberstops[0] = sizeof(_gradient_gray)/sizeof(dt_iop_gui_blendif_colorstop_t);
bd->colorstops[1] = _gradient_red;
bd->numberstops[1] = sizeof(_gradient_red)/sizeof(dt_iop_gui_blendif_colorstop_t);
bd->colorstops[2] = _gradient_green;
bd->numberstops[2] = sizeof(_gradient_green)/sizeof(dt_iop_gui_blendif_colorstop_t);
bd->colorstops[3] = _gradient_blue;
bd->numberstops[3] = sizeof(_gradient_blue)/sizeof(dt_iop_gui_blendif_colorstop_t);
bd->colorstops[4] = _gradient_HUE;
bd->numberstops[4] = sizeof(_gradient_HUE)/sizeof(dt_iop_gui_blendif_colorstop_t);
bd->colorstops[5] = _gradient_chroma;
bd->numberstops[5] = sizeof(_gradient_chroma)/sizeof(dt_iop_gui_blendif_colorstop_t);
bd->colorstops[6] = _gradient_gray;
bd->numberstops[6] = sizeof(_gradient_gray)/sizeof(dt_iop_gui_blendif_colorstop_t);
break;
default:
assert(FALSE); // blendif not supported for RAW, which is already catched upstream; we should not get here
}
bd->blendif_box = GTK_VBOX(gtk_vbox_new(FALSE,DT_GUI_IOP_MODULE_CONTROL_SPACING));
GtkWidget *uplabel = gtk_hbox_new(FALSE,0);
GtkWidget *lowlabel = gtk_hbox_new(FALSE,0);
GtkWidget *upslider = gtk_hbox_new(FALSE,0);
GtkWidget *lowslider = gtk_hbox_new(FALSE,0);
GtkWidget *notebook = gtk_vbox_new(FALSE,0);
GtkWidget *header = gtk_hbox_new(FALSE, 0);
bd->blendif_enable = dt_bauhaus_combobox_new(module);
dt_bauhaus_widget_set_label(bd->blendif_enable, _("blend"));
dt_bauhaus_combobox_add(bd->blendif_enable, _("uniformly"));
dt_bauhaus_combobox_add(bd->blendif_enable, _("only, if.."));
dt_bauhaus_combobox_set(bd->blendif_enable, 0);
bd->channel_tabs = GTK_NOTEBOOK(gtk_notebook_new());
for(int ch=0; ch<maxchannels; ch++)
{
gtk_notebook_append_page(GTK_NOTEBOOK(bd->channel_tabs), GTK_WIDGET(gtk_hbox_new(FALSE,0)), gtk_label_new(labels[ch]));
g_object_set(G_OBJECT(gtk_notebook_get_tab_label(bd->channel_tabs, gtk_notebook_get_nth_page(bd->channel_tabs, -1))), "tooltip-text", tooltips[ch], NULL);
}
gtk_widget_show_all(GTK_WIDGET(gtk_notebook_get_nth_page(bd->channel_tabs, bd->tab)));
gtk_notebook_set_current_page(GTK_NOTEBOOK(bd->channel_tabs), bd->tab);
g_object_set(G_OBJECT(bd->channel_tabs), "homogeneous", TRUE, (char *)NULL);
gtk_notebook_set_scrollable(bd->channel_tabs, TRUE);
gtk_box_pack_start(GTK_BOX(notebook), GTK_WIDGET(bd->channel_tabs), FALSE, FALSE, 0);
bd->colorpicker = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(bd->colorpicker), "tooltip-text", _("pick gui color from image"), (char *)NULL);
bd->showmask = dtgtk_togglebutton_new(dtgtk_cairo_paint_showmask, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(bd->showmask), "tooltip-text", _("display mask"), (char *)NULL);
GtkWidget *res = dtgtk_button_new(dtgtk_cairo_paint_reset, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(res), "tooltip-text", _("reset blend mask settings"), (char *)NULL);
bd->suppress = dtgtk_togglebutton_new(dtgtk_cairo_paint_eye_toggle, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(bd->suppress), "tooltip-text", _("temporarily switch off blend mask. only for module in focus."), (char *)NULL);
gtk_box_pack_start(GTK_BOX(header), GTK_WIDGET(notebook), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(header), GTK_WIDGET(res), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(header), GTK_WIDGET(bd->colorpicker), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(header), GTK_WIDGET(bd->showmask), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(header), GTK_WIDGET(bd->suppress), FALSE, FALSE, 0);
bd->lower_slider = DTGTK_GRADIENT_SLIDER_MULTIVALUE(dtgtk_gradient_slider_multivalue_new(4));
bd->upper_slider = DTGTK_GRADIENT_SLIDER_MULTIVALUE(dtgtk_gradient_slider_multivalue_new(4));
bd->lower_polarity = dtgtk_togglebutton_new(dtgtk_cairo_paint_plusminus, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
g_object_set(G_OBJECT(bd->lower_polarity), "tooltip-text", _("toggle polarity. best seen by enabling 'display mask'"), (char *)NULL);
bd->upper_polarity = dtgtk_togglebutton_new(dtgtk_cairo_paint_plusminus, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
g_object_set(G_OBJECT(bd->upper_polarity), "tooltip-text", _("toggle polarity. best seen by enabling 'display mask'"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(upslider), GTK_WIDGET(bd->upper_slider), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(upslider), GTK_WIDGET(bd->upper_polarity), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lowslider), GTK_WIDGET(bd->lower_slider), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(lowslider), GTK_WIDGET(bd->lower_polarity), FALSE, FALSE, 0);
GtkWidget *output = gtk_label_new(_("output"));
bd->upper_picker_label = GTK_LABEL(gtk_label_new(""));
gtk_box_pack_start(GTK_BOX(uplabel), GTK_WIDGET(output), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(uplabel), GTK_WIDGET(bd->upper_picker_label), TRUE, TRUE, 0);
for(int k=0; k < 4 ; k++)
{
bd->upper_label[k] = GTK_LABEL(gtk_label_new(NULL));
gtk_label_set_width_chars(bd->upper_label[k], 5);
gtk_box_pack_start(GTK_BOX(uplabel), GTK_WIDGET(bd->upper_label[k]), FALSE, FALSE, 0);
}
GtkWidget *input = gtk_label_new(_("input"));
bd->lower_picker_label = GTK_LABEL(gtk_label_new(""));
gtk_box_pack_start(GTK_BOX(lowlabel), GTK_WIDGET(input), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lowlabel), GTK_WIDGET(bd->lower_picker_label), TRUE, TRUE, 0);
for(int k=0; k < 4 ; k++)
{
bd->lower_label[k] = GTK_LABEL(gtk_label_new(NULL));
gtk_label_set_width_chars(bd->lower_label[k], 5);
gtk_box_pack_start(GTK_BOX(lowlabel), GTK_WIDGET(bd->lower_label[k]), FALSE, FALSE, 0);
}
bd->radius_slider = dt_bauhaus_slider_new_with_range(module, 0.0, 50.0, 0.1, 0.0, 1);
dt_bauhaus_widget_set_label(bd->radius_slider, _("mask blur"));
dt_bauhaus_slider_set_format(bd->radius_slider, "%.1f");
gtk_object_set(GTK_OBJECT(bd->blendif_enable), "tooltip-text", _("enable conditional blending"), (char *)NULL);
gtk_object_set(GTK_OBJECT(bd->lower_slider), "tooltip-text", _("double click to reset"), (char *)NULL);
gtk_object_set(GTK_OBJECT(bd->upper_slider), "tooltip-text", _("double click to reset"), (char *)NULL);
gtk_object_set(GTK_OBJECT(output), "tooltip-text", ttoutput, (char *)NULL);
gtk_object_set(GTK_OBJECT(input), "tooltip-text", ttinput, (char *)NULL);
gtk_object_set(GTK_OBJECT(bd->radius_slider), "tooltip-text", _("radius for gaussian blur of blend mask"), (char *)NULL);
g_signal_connect (G_OBJECT (bd->lower_slider), "expose-event",
G_CALLBACK (_blendop_blendif_expose), module);
g_signal_connect (G_OBJECT (bd->upper_slider), "expose-event",
G_CALLBACK (_blendop_blendif_expose), module);
g_signal_connect (G_OBJECT (bd->blendif_enable), "value-changed",
G_CALLBACK (_blendop_blendif_callback), bd);
g_signal_connect(G_OBJECT (bd->channel_tabs), "switch_page",
G_CALLBACK (_blendop_blendif_tab_switch), bd);
g_signal_connect (G_OBJECT (bd->upper_slider), "value-changed",
G_CALLBACK (_blendop_blendif_upper_callback), bd);
g_signal_connect (G_OBJECT (bd->radius_slider), "value-changed",
G_CALLBACK (_blendop_blendif_radius_callback), bd);
g_signal_connect (G_OBJECT (bd->lower_slider), "value-changed",
G_CALLBACK (_blendop_blendif_lower_callback), bd);
g_signal_connect (G_OBJECT(bd->colorpicker), "toggled",
G_CALLBACK (_blendop_blendif_pick_toggled), module);
g_signal_connect (G_OBJECT(bd->showmask), "toggled",
G_CALLBACK (_blendop_blendif_showmask_toggled), module);
g_signal_connect (G_OBJECT(res), "clicked",
G_CALLBACK (_blendop_blendif_reset), module);
g_signal_connect (G_OBJECT(bd->suppress), "toggled",
G_CALLBACK (_blendop_blendif_suppress_toggled), module);
g_signal_connect (G_OBJECT(bd->lower_polarity), "toggled",
G_CALLBACK (_blendop_blendif_polarity_callback), bd);
g_signal_connect (G_OBJECT(bd->upper_polarity), "toggled",
G_CALLBACK (_blendop_blendif_polarity_callback), bd);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(header), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(uplabel), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(upslider), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(lowlabel), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(lowslider), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bd->blendif_box), GTK_WIDGET(bd->radius_slider), TRUE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(blendw), GTK_WIDGET(bd->blendif_box),TRUE,TRUE,0);
gtk_box_pack_end(GTK_BOX(blendw), GTK_WIDGET(bd->blendif_enable),TRUE,TRUE,0);
bd->blendif_inited = 1;
}
}
