void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_basecurve_gui_data_t));
dt_iop_basecurve_gui_data_t *c = (dt_iop_basecurve_gui_data_t *)self->gui_data;
dt_iop_basecurve_params_t *p = (dt_iop_basecurve_params_t *)self->params;
c->minmax_curve = dt_draw_curve_new(0.0, 1.0, p->basecurve_type[0]);
c->minmax_curve_type = p->basecurve_type[0];
c->minmax_curve_nodes = p->basecurve_nodes[0];
for(int k = 0; k < p->basecurve_nodes[0]; k++)
(void)dt_draw_curve_add_point(c->minmax_curve, p->basecurve[0][k].x, p->basecurve[0][k].y);
c->mouse_x = c->mouse_y = -1.0;
c->selected = -1;
c->loglogscale = 0;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
c->area = GTK_DRAWING_AREA(dtgtk_drawing_area_new_with_aspect_ratio(1.0));
gtk_widget_set_tooltip_text(GTK_WIDGET(c->area), _("abscissa: input, ordinate: output. works on RGB channels"));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(c->area), TRUE, TRUE, 0);
c->scale = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(c->scale, NULL, _("scale"));
dt_bauhaus_combobox_add(c->scale, _("linear"));
dt_bauhaus_combobox_add(c->scale, _("logarithmic"));
gtk_widget_set_tooltip_text(c->scale, _("scale to use in the graph. use logarithmic scale for "
"more precise control near the blacks"));
gtk_box_pack_start(GTK_BOX(self->widget), c->scale, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(c->scale), "value-changed", G_CALLBACK(scale_callback), self);
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_basecurve_draw), self);
g_signal_connect(G_OBJECT(c->area), "button-press-event", G_CALLBACK(dt_iop_basecurve_button_press), self);
g_signal_connect(G_OBJECT(c->area), "motion-notify-event", G_CALLBACK(dt_iop_basecurve_motion_notify), self);
g_signal_connect(G_OBJECT(c->area), "leave-notify-event", G_CALLBACK(dt_iop_basecurve_leave_notify), self);
g_signal_connect(G_OBJECT(c->area), "enter-notify-event", G_CALLBACK(dt_iop_basecurve_enter_notify), self);
g_signal_connect(G_OBJECT(c->area), "configure-event", G_CALLBACK(area_resized), self);
g_signal_connect(G_OBJECT(c->area), "scroll-event", G_CALLBACK(_scrolled), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_colorcorrection_gui_data_t));
dt_iop_colorcorrection_gui_data_t *g = (dt_iop_colorcorrection_gui_data_t *)self->gui_data;
g->selected = 0;
self->widget = gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE);
g->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(g->area));
gtk_drawing_area_size(g->area, 258, 258);
g_object_set (GTK_OBJECT(g->area), "tooltip-text", _("drag the line for split toning. "
"bright means highlights, dark means shadows. "
"use mouse wheel to change saturation."), (char *)NULL);
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);
g_signal_connect (G_OBJECT (g->area), "expose-event",
G_CALLBACK (dt_iop_colorcorrection_expose), self);
g_signal_connect (G_OBJECT (g->area), "button-press-event",
G_CALLBACK (dt_iop_colorcorrection_button_press), self);
g_signal_connect (G_OBJECT (g->area), "motion-notify-event",
G_CALLBACK (dt_iop_colorcorrection_motion_notify), self);
g_signal_connect (G_OBJECT (g->area), "leave-notify-event",
G_CALLBACK (dt_iop_colorcorrection_leave_notify), self);
g_signal_connect (G_OBJECT (g->area), "scroll-event",
G_CALLBACK (dt_iop_colorcorrection_scrolled), self);
g->slider = dt_bauhaus_slider_new_with_range(self, -3.0f, 3.0f, 0.01f, 1.0f, 2);
gtk_box_pack_start(GTK_BOX(self->widget), g->slider, TRUE, TRUE, 0);
g_object_set (GTK_OBJECT(g->slider), "tooltip-text", _("set the global saturation"), (char *)NULL);
dt_bauhaus_widget_set_label(g->slider,_("saturation"));
g_signal_connect (G_OBJECT (g->slider), "value-changed",
G_CALLBACK (sat_callback), self);
g->hsRGB = dt_colorspaces_create_srgb_profile();
g->hLab = dt_colorspaces_create_lab_profile();
g->xform = cmsCreateTransform(g->hLab, TYPE_Lab_DBL, g->hsRGB, TYPE_RGB_DBL,
INTENT_PERCEPTUAL, 0);//cmsFLAGS_NOTPRECALC);
}
/** 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(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->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
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 | GDK_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);
g->highlights = dt_bauhaus_slider_new_with_range(self, 0.0, 1.0, 0.01, 0.0, 2);
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
dt_bauhaus_widget_set_quad_paint(g->highlights, dtgtk_cairo_paint_colorpicker, CPF_ACTIVE);
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(self->widget), g->highlights, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(g->highlights), "value-changed", G_CALLBACK(highlights_callback), self);
g_signal_connect(G_OBJECT(g->highlights), "quad-pressed", G_CALLBACK(picker_callback), self);
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_colorcorrection_gui_data_t));
dt_iop_colorcorrection_gui_data_t *g = (dt_iop_colorcorrection_gui_data_t *)self->gui_data;
g->selected = 0;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
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);
g_object_set(G_OBJECT(g->area), "tooltip-text", _("drag the line for split toning. "
"bright means highlights, dark means shadows. "
"use mouse wheel to change saturation."),
(char *)NULL);
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 | GDK_SCROLL_MASK);
g_signal_connect(G_OBJECT(g->area), "draw", G_CALLBACK(dt_iop_colorcorrection_draw), self);
g_signal_connect(G_OBJECT(g->area), "button-press-event", G_CALLBACK(dt_iop_colorcorrection_button_press),
self);
g_signal_connect(G_OBJECT(g->area), "motion-notify-event", G_CALLBACK(dt_iop_colorcorrection_motion_notify),
self);
g_signal_connect(G_OBJECT(g->area), "leave-notify-event", G_CALLBACK(dt_iop_colorcorrection_leave_notify),
self);
g_signal_connect(G_OBJECT(g->area), "scroll-event", G_CALLBACK(dt_iop_colorcorrection_scrolled), self);
g->slider = dt_bauhaus_slider_new_with_range(self, -3.0f, 3.0f, 0.01f, 1.0f, 2);
gtk_box_pack_start(GTK_BOX(self->widget), g->slider, TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->slider), "tooltip-text", _("set the global saturation"), (char *)NULL);
dt_bauhaus_widget_set_label(g->slider, NULL, _("saturation"));
g_signal_connect(G_OBJECT(g->slider), "value-changed", G_CALLBACK(sat_callback), self);
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_graduatednd_gui_data_t));
dt_iop_graduatednd_gui_data_t *g = (dt_iop_graduatednd_gui_data_t *)self->gui_data;
dt_iop_graduatednd_params_t *p = (dt_iop_graduatednd_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
/* density */
g->scale1 = dt_bauhaus_slider_new_with_range(self, -8.0, 8.0, 0.1, p->density, 2);
dt_bauhaus_slider_set_format(g->scale1, "%.2fev");
dt_bauhaus_widget_set_label(g->scale1, NULL, _("density"));
gtk_widget_set_tooltip_text(g->scale1, _("the density in EV for the filter"));
g_signal_connect(G_OBJECT(g->scale1), "value-changed", G_CALLBACK(density_callback), self);
/* compression */
g->scale2 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->compression, 0);
dt_bauhaus_slider_set_format(g->scale2, "%.0f%%");
dt_bauhaus_widget_set_label(g->scale2, NULL, _("compression"));
/* xgettext:no-c-format */
gtk_widget_set_tooltip_text(g->scale2, _("compression of graduation:\n0% = soft, 100% = hard"));
g_signal_connect(G_OBJECT(g->scale2), "value-changed", G_CALLBACK(compression_callback), self);
/* rotation */
g->scale3 = dt_bauhaus_slider_new_with_range(self, -180, 180, 0.5, p->rotation, 2);
dt_bauhaus_widget_set_label(g->scale3, NULL, _("rotation"));
dt_bauhaus_slider_set_format(g->scale3, "%.2f°");
gtk_widget_set_tooltip_text(g->scale3, _("rotation of filter -180 to 180 degrees"));
g_signal_connect(G_OBJECT(g->scale3), "value-changed", G_CALLBACK(rotation_callback), self);
/* add widgets to ui */
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale3), TRUE, TRUE, 0);
/* hue slider */
g->gslider1 = dt_bauhaus_slider_new_with_range_and_feedback(self, 0.0f, 1.0f, 0.01f, 0.0f, 2, 0);
dt_bauhaus_slider_set_stop(g->gslider1, 0.0f, 1.0f, 0.0f, 0.0f);
// dt_bauhaus_slider_set_format(g->gslider1, "");
dt_bauhaus_widget_set_label(g->gslider1, NULL, _("hue"));
dt_bauhaus_slider_set_stop(g->gslider1, 0.166f, 1.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(g->gslider1, 0.322f, 0.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(g->gslider1, 0.498f, 0.0f, 1.0f, 1.0f);
dt_bauhaus_slider_set_stop(g->gslider1, 0.664f, 0.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(g->gslider1, 0.830f, 1.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(g->gslider1, 1.0f, 1.0f, 0.0f, 0.0f);
gtk_widget_set_tooltip_text(g->gslider1, _("select the hue tone of filter"));
g_signal_connect(G_OBJECT(g->gslider1), "value-changed", G_CALLBACK(hue_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->gslider1, TRUE, TRUE, 0);
/* saturation slider */
g->gslider2 = dt_bauhaus_slider_new_with_range(self, 0.0f, 1.0f, 0.01f, 0.0f, 2);
dt_bauhaus_widget_set_label(g->gslider2, NULL, _("saturation"));
dt_bauhaus_slider_set_stop(g->gslider2, 0.0f, 0.2f, 0.2f, 0.2f);
dt_bauhaus_slider_set_stop(g->gslider2, 1.0f, 1.0f, 1.0f, 1.0f);
gtk_widget_set_tooltip_text(g->gslider2, _("select the saturation of filter"));
g_signal_connect(G_OBJECT(g->gslider2), "value-changed", G_CALLBACK(saturation_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->gslider2, TRUE, TRUE, 0);
g->selected = 0;
g->dragging = 0;
g->define = 0;
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_colorout_gui_data_t));
memset(self->gui_data,0,sizeof(dt_iop_colorout_gui_data_t));
dt_iop_colorout_gui_data_t *g = (dt_iop_colorout_gui_data_t *)self->gui_data;
g->profiles = NULL;
dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "sRGB", sizeof(prof->filename));
g_strlcpy(prof->name, "sRGB", sizeof(prof->name));
int pos;
int display_pos;
prof->pos = 0;
prof->display_pos = 0;
g->profiles = g_list_append(g->profiles, prof);
prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "adobergb", sizeof(prof->filename));
g_strlcpy(prof->name, "adobergb", sizeof(prof->name));
prof->pos = 1;
prof->display_pos = 1;
g->profiles = g_list_append(g->profiles, prof);
prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "X profile", sizeof(prof->filename));
g_strlcpy(prof->name, "X profile", sizeof(prof->name));
prof->pos = -1;
prof->display_pos = 2;
g->profiles = g_list_append(g->profiles, prof);
prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "linear_rgb", sizeof(prof->filename));
g_strlcpy(prof->name, "linear_rgb", sizeof(prof->name));
pos = prof->pos = 2;
display_pos = prof->display_pos = 3;
g->profiles = g_list_append(g->profiles, prof);
// read {conf,data}dir/color/out/*.icc
char datadir[DT_MAX_PATH_LEN];
char confdir[DT_MAX_PATH_LEN];
char dirname[DT_MAX_PATH_LEN];
char filename[DT_MAX_PATH_LEN];
dt_loc_get_user_config_dir(confdir, DT_MAX_PATH_LEN);
dt_loc_get_datadir(datadir, DT_MAX_PATH_LEN);
snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", confdir);
if(!g_file_test(dirname, G_FILE_TEST_IS_DIR))
snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", datadir);
cmsHPROFILE tmpprof;
const gchar *d_name;
GDir *dir = g_dir_open(dirname, 0, NULL);
if(dir)
{
while((d_name = g_dir_read_name(dir)))
{
snprintf(filename, DT_MAX_PATH_LEN, "%s/%s", dirname, d_name);
tmpprof = cmsOpenProfileFromFile(filename, "r");
if(tmpprof)
{
char *lang = getenv("LANG");
if (!lang) lang = "en_US";
dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
char name[1024];
cmsGetProfileInfoASCII(tmpprof, cmsInfoDescription, lang, lang+3, name, 1024);
g_strlcpy(prof->name, name, sizeof(prof->name));
g_strlcpy(prof->filename, d_name, sizeof(prof->filename));
prof->pos = ++pos;
prof->display_pos = ++display_pos;
cmsCloseProfile(tmpprof);
g->profiles = g_list_append(g->profiles, prof);
}
}
g_dir_close(dir);
}
self->widget = gtk_vbox_new(TRUE, DT_BAUHAUS_SPACE);
// TODO:
g->cbox1 = dt_bauhaus_combobox_new(self);
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox1, TRUE, TRUE, 0);
dt_bauhaus_widget_set_label(g->cbox1, _("output intent"));
dt_bauhaus_combobox_add(g->cbox1, _("perceptual"));
dt_bauhaus_combobox_add(g->cbox1, _("relative colorimetric"));
dt_bauhaus_combobox_add(g->cbox1, C_("rendering intent", "saturation"));
dt_bauhaus_combobox_add(g->cbox1, _("absolute colorimetric"));
g->cbox4 = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->cbox4, _("display intent"));
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox4, TRUE, TRUE, 0);
dt_bauhaus_combobox_add(g->cbox4, _("perceptual"));
dt_bauhaus_combobox_add(g->cbox4, _("relative colorimetric"));
dt_bauhaus_combobox_add(g->cbox4, C_("rendering intent", "saturation"));
dt_bauhaus_combobox_add(g->cbox4, _("absolute colorimetric"));
g->cbox2 = dt_bauhaus_combobox_new(self);
g->cbox3 = dt_bauhaus_combobox_new(self);
g->cbox5 = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->cbox2, _("output profile"));
dt_bauhaus_widget_set_label(g->cbox5, _("softproof profile"));
dt_bauhaus_widget_set_label(g->cbox3, _("display profile"));
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox5, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox3, TRUE, TRUE, 0);
GList *l = g->profiles;
while(l)
{
dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)l->data;
if(!strcmp(prof->name, "X profile"))
{
// the system display profile is only suitable for display purposes
dt_bauhaus_combobox_add(g->cbox3, _("system display profile"));
}
else if(!strcmp(prof->name, "linear_rgb"))
{
dt_bauhaus_combobox_add(g->cbox2, _("linear RGB"));
dt_bauhaus_combobox_add(g->cbox3, _("linear RGB"));
dt_bauhaus_combobox_add(g->cbox5, _("linear RGB"));
}
else if(!strcmp(prof->name, "sRGB"))
{
dt_bauhaus_combobox_add(g->cbox2, _("sRGB (web-safe)"));
dt_bauhaus_combobox_add(g->cbox3, _("sRGB (web-safe)"));
dt_bauhaus_combobox_add(g->cbox5, _("sRGB (web-safe)"));
}
else if(!strcmp(prof->name, "adobergb"))
{
dt_bauhaus_combobox_add(g->cbox2, _("Adobe RGB"));
dt_bauhaus_combobox_add(g->cbox3, _("Adobe RGB"));
dt_bauhaus_combobox_add(g->cbox5, _("Adobe RGB"));
}
else
{
dt_bauhaus_combobox_add(g->cbox2, prof->name);
dt_bauhaus_combobox_add(g->cbox3, prof->name);
dt_bauhaus_combobox_add(g->cbox5, prof->name);
}
l = g_list_next(l);
}
char tooltip[1024];
g_object_set(G_OBJECT(g->cbox1), "tooltip-text", _("rendering intent"), (char *)NULL);
snprintf(tooltip, 1024, _("icc profiles in %s/color/out or %s/color/out"), confdir, datadir);
g_object_set(G_OBJECT(g->cbox2), "tooltip-text", tooltip, (char *)NULL);
snprintf(tooltip, 1024, _("display icc profiles in %s/color/out or %s/color/out"), confdir, datadir);
g_object_set(G_OBJECT(g->cbox3), "tooltip-text", tooltip, (char *)NULL);
snprintf(tooltip, 1024, _("softproof icc profiles in %s/color/out or %s/color/out"), confdir, datadir);
g_object_set(G_OBJECT(g->cbox5), "tooltip-text", tooltip, (char *)NULL);
g_signal_connect (G_OBJECT (g->cbox1), "value-changed",
G_CALLBACK (intent_changed),
(gpointer)self);
g_signal_connect (G_OBJECT (g->cbox4), "value-changed",
G_CALLBACK (display_intent_changed),
(gpointer)self);
g_signal_connect (G_OBJECT (g->cbox2), "value-changed",
G_CALLBACK (output_profile_changed),
(gpointer)self);
g_signal_connect (G_OBJECT (g->cbox3), "value-changed",
G_CALLBACK (display_profile_changed),
(gpointer)self);
g_signal_connect (G_OBJECT (g->cbox5), "value-changed",
G_CALLBACK (softproof_profile_changed),
(gpointer)self);
// reload the profiles when the display profile changed!
dt_control_signal_connect(darktable.signals, DT_SIGNAL_CONTROL_PROFILE_CHANGED,
G_CALLBACK(_signal_profile_changed), 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(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 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_exposure_gui_data_t));
dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data;
dt_iop_exposure_params_t *p = (dt_iop_exposure_params_t *)self->params;
/* register hooks with current dev so that histogram
can interact with this module.
*/
darktable.develop->proxy.exposure.module = self;
darktable.develop->proxy.exposure.set_white = dt_iop_exposure_set_white;
darktable.develop->proxy.exposure.get_white = dt_iop_exposure_get_white;
darktable.develop->proxy.exposure.set_black = dt_iop_exposure_set_black;
darktable.develop->proxy.exposure.get_black = dt_iop_exposure_get_black;
self->request_color_pick = 0;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE));
g->black = dt_bauhaus_slider_new_with_range(self, -0.1, 0.1, .001, p->black, 4);
g_object_set(G_OBJECT(g->black), "tooltip-text", _("adjust the black level"), (char *)NULL);
dt_bauhaus_slider_set_format(g->black,"%.4f");
dt_bauhaus_widget_set_label(g->black, NULL, _("black"));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->black), TRUE, TRUE, 0);
g->exposure = dt_bauhaus_slider_new_with_range(self, -3.0, 3.0, .02, p->exposure, 3);
g_object_set(G_OBJECT(g->exposure), "tooltip-text", _("adjust the exposure correction"), (char *)NULL);
dt_bauhaus_slider_set_format(g->exposure,"%.2fEV");
dt_bauhaus_widget_set_label(g->exposure, NULL, _("exposure"));
dt_bauhaus_slider_enable_soft_boundaries(g->exposure, -18.0, 18.0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->exposure), TRUE, TRUE, 0);
g->autoexp = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("auto")));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoexp), FALSE);
g->autoexpp = dt_bauhaus_slider_new_with_range(self, 0.0, 0.2, .001, 0.01,3);
g_object_set(G_OBJECT(g->autoexpp), "tooltip-text", _("percentage of bright values clipped out"), (char *)NULL);
gtk_widget_set_sensitive(GTK_WIDGET(g->autoexpp), TRUE);
GtkHBox *hbox = GTK_HBOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexp), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexpp), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
g->deflicker = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("deflicker")));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->deflicker), p->deflicker);
g->deflicker_percentile = dt_bauhaus_slider_new_with_range(self, 0, 100, .01, p->deflicker_percentile, 3);
g_object_set(G_OBJECT(g->deflicker_percentile), "tooltip-text", _("percentile"), (char *)NULL);
dt_bauhaus_slider_set_format(g->deflicker_percentile,"%.2f%%");
dt_bauhaus_widget_set_label(g->deflicker_percentile, NULL, _("percentile"));
gtk_widget_set_sensitive(GTK_WIDGET(g->deflicker_percentile), p->deflicker);
g->deflicker_level = dt_bauhaus_slider_new_with_range(self, -18.0, 18.0, .01, p->deflicker_level, 3);
g_object_set(G_OBJECT(g->deflicker_level), "tooltip-text", _("target level"), (char *)NULL);
dt_bauhaus_slider_set_format(g->deflicker_level,"%.2fEV");
dt_bauhaus_widget_set_label(g->deflicker_level, NULL, _("target level"));
gtk_widget_set_sensitive(GTK_WIDGET(g->deflicker_level), p->deflicker);
GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE));
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->deflicker_percentile), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->deflicker_level), TRUE, TRUE, 0);
GtkHBox *hbox2 = GTK_HBOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox2), GTK_WIDGET(g->deflicker), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox2), GTK_WIDGET(vbox), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox2), TRUE, TRUE, 0);
darktable.gui->reset = 1;
self->gui_update(self);
darktable.gui->reset = 0;
g_signal_connect (G_OBJECT (g->black), "value-changed",
G_CALLBACK (black_callback), self);
g_signal_connect (G_OBJECT (g->exposure), "value-changed",
G_CALLBACK (exposure_callback), self);
g_signal_connect (G_OBJECT (g->autoexpp), "value-changed",
G_CALLBACK (autoexpp_callback), self);
g_signal_connect (G_OBJECT (g->autoexp), "toggled",
G_CALLBACK (autoexp_callback), self);
g_signal_connect (G_OBJECT (g->deflicker), "toggled",
G_CALLBACK (deflicker_callback), self);
g_signal_connect (G_OBJECT (g->deflicker_percentile), "value-changed",
G_CALLBACK (deflicker_params_callback), self);
g_signal_connect (G_OBJECT (g->deflicker_level), "value-changed",
G_CALLBACK (deflicker_params_callback), self);
g_signal_connect (G_OBJECT(self->widget), "expose-event",
G_CALLBACK(expose), self);
}
void gui_init(dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_colorbalance_gui_data_t));
dt_iop_colorbalance_gui_data_t *g = (dt_iop_colorbalance_gui_data_t *)self->gui_data;
dt_iop_colorbalance_params_t *p = (dt_iop_colorbalance_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_BAUHAUS_SPACE);
gtk_box_pack_start(GTK_BOX(self->widget), hbox, FALSE, FALSE, 0);
#ifdef SHOW_COLOR_WHEELS
GtkWidget *area = dtgtk_drawing_area_new_with_aspect_ratio(1.0);
gtk_box_pack_start(GTK_BOX(hbox), area, TRUE, TRUE, 0);
// gtk_widget_add_events(g->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(area), "draw", G_CALLBACK(dt_iop_area_draw), self);
// g_signal_connect (G_OBJECT (area), "button-press-event",
// G_CALLBACK (dt_iop_colorbalance_button_press), self);
// g_signal_connect (G_OBJECT (area), "motion-notify-event",
// G_CALLBACK (dt_iop_colorbalance_motion_notify), self);
// g_signal_connect (G_OBJECT (area), "leave-notify-event",
// G_CALLBACK (dt_iop_colorbalance_leave_notify), self);
area = dtgtk_drawing_area_new_with_aspect_ratio(1.0);
gtk_box_pack_start(GTK_BOX(hbox), area, TRUE, TRUE, 0);
// gtk_widget_add_events(g->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(area), "draw", G_CALLBACK(dt_iop_area_draw), self);
// g_signal_connect (G_OBJECT (area), "button-press-event",
// G_CALLBACK (dt_iop_colorbalance_button_press), self);
// g_signal_connect (G_OBJECT (area), "motion-notify-event",
// G_CALLBACK (dt_iop_colorbalance_motion_notify), self);
// g_signal_connect (G_OBJECT (area), "leave-notify-event",
// G_CALLBACK (dt_iop_colorbalance_leave_notify), self);
area = dtgtk_drawing_area_new_with_aspect_ratio(1.0);
gtk_box_pack_start(GTK_BOX(hbox), area, TRUE, TRUE, 0);
// gtk_widget_add_events(g->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(area), "draw", G_CALLBACK(dt_iop_area_draw), self);
// g_signal_connect (G_OBJECT (area), "button-press-event",
// G_CALLBACK (dt_iop_colorbalance_button_press), self);
// g_signal_connect (G_OBJECT (area), "motion-notify-event",
// G_CALLBACK (dt_iop_colorbalance_motion_notify), self);
// g_signal_connect (G_OBJECT (area), "leave-notify-event",
// G_CALLBACK (dt_iop_colorbalance_leave_notify), self);
#endif
/* lift */
gtk_box_pack_start(GTK_BOX(self->widget), dt_ui_section_label_new(_("lift")), FALSE, FALSE, 5);
g->lift_factor
= dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->lift[CHANNEL_FACTOR] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->lift_factor, 0.0, 0.0, 0.0, 0.0);
dt_bauhaus_slider_set_stop(g->lift_factor, 1.0, 1.0, 1.0, 1.0);
g_object_set(g->lift_factor, "tooltip-text", _("factor of lift"), (char *)NULL);
dt_bauhaus_widget_set_label(g->lift_factor, _("lift"), _("factor"));
g_signal_connect(G_OBJECT(g->lift_factor), "value-changed", G_CALLBACK(lift_factor_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->lift_factor, TRUE, TRUE, 0);
g->lift_r = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->lift[CHANNEL_RED] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->lift_r, 0.0, 0.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->lift_r, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->lift_r, 1.0, 1.0, 0.0, 0.0);
g_object_set(g->lift_r, "tooltip-text", _("factor of red for lift"), (char *)NULL);
dt_bauhaus_widget_set_label(g->lift_r, _("lift"), _("red"));
g_signal_connect(G_OBJECT(g->lift_r), "value-changed", G_CALLBACK(lift_red_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->lift_r, TRUE, TRUE, 0);
g->lift_g = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->lift[CHANNEL_GREEN] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->lift_g, 0.0, 1.0, 0.0, 1.0);
dt_bauhaus_slider_set_stop(g->lift_g, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->lift_g, 1.0, 0.0, 1.0, 0.0);
g_object_set(g->lift_g, "tooltip-text", _("factor of green for lift"), (char *)NULL);
dt_bauhaus_widget_set_label(g->lift_g, _("lift"), _("green"));
g_signal_connect(G_OBJECT(g->lift_g), "value-changed", G_CALLBACK(lift_green_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->lift_g, TRUE, TRUE, 0);
g->lift_b = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->lift[CHANNEL_BLUE] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->lift_b, 0.0, 1.0, 1.0, 0.0);
dt_bauhaus_slider_set_stop(g->lift_b, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->lift_b, 1.0, 0.0, 0.0, 1.0);
g_object_set(g->lift_b, "tooltip-text", _("factor of blue for lift"), (char *)NULL);
dt_bauhaus_widget_set_label(g->lift_b, _("lift"), _("blue"));
g_signal_connect(G_OBJECT(g->lift_b), "value-changed", G_CALLBACK(lift_blue_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->lift_b, TRUE, TRUE, 0);
/* gamma */
gtk_box_pack_start(GTK_BOX(self->widget), dt_ui_section_label_new(_("gamma")), FALSE, FALSE, 5);
g->gamma_factor
= dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->gamma[CHANNEL_FACTOR] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->gamma_factor, 0.0, 0.0, 0.0, 0.0);
dt_bauhaus_slider_set_stop(g->gamma_factor, 1.0, 1.0, 1.0, 1.0);
g_object_set(g->gamma_factor, "tooltip-text", _("factor of gamma"), (char *)NULL);
dt_bauhaus_widget_set_label(g->gamma_factor, _("gamma"), _("factor"));
g_signal_connect(G_OBJECT(g->gamma_factor), "value-changed", G_CALLBACK(gamma_factor_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->gamma_factor, TRUE, TRUE, 0);
g->gamma_r = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->gamma[CHANNEL_RED] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->gamma_r, 0.0, 0.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->gamma_r, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->gamma_r, 1.0, 1.0, 0.0, 0.0);
g_object_set(g->gamma_r, "tooltip-text", _("factor of red for gamma"), (char *)NULL);
dt_bauhaus_widget_set_label(g->gamma_r, _("gamma"), _("red"));
g_signal_connect(G_OBJECT(g->gamma_r), "value-changed", G_CALLBACK(gamma_red_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->gamma_r, TRUE, TRUE, 0);
g->gamma_g = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->gamma[CHANNEL_GREEN] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->gamma_g, 0.0, 1.0, 0.0, 1.0);
dt_bauhaus_slider_set_stop(g->gamma_g, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->gamma_g, 1.0, 0.0, 1.0, 0.0);
g_object_set(g->gamma_g, "tooltip-text", _("factor of green for gamma"), (char *)NULL);
dt_bauhaus_widget_set_label(g->gamma_g, _("gamma"), _("green"));
g_signal_connect(G_OBJECT(g->gamma_g), "value-changed", G_CALLBACK(gamma_green_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->gamma_g, TRUE, TRUE, 0);
g->gamma_b = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->gamma[CHANNEL_BLUE] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->gamma_b, 0.0, 1.0, 1.0, 0.0);
dt_bauhaus_slider_set_stop(g->gamma_b, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->gamma_b, 1.0, 0.0, 0.0, 1.0);
g_object_set(g->gamma_b, "tooltip-text", _("factor of blue for gamma"), (char *)NULL);
dt_bauhaus_widget_set_label(g->gamma_b, _("gamma"), _("blue"));
g_signal_connect(G_OBJECT(g->gamma_b), "value-changed", G_CALLBACK(gamma_blue_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->gamma_b, TRUE, TRUE, 0);
/* gain */
gtk_box_pack_start(GTK_BOX(self->widget), dt_ui_section_label_new(_("gain")), FALSE, FALSE, 5);
g->gain_factor
= dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->gain[CHANNEL_FACTOR] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->gain_factor, 0.0, 0.0, 0.0, 0.0);
dt_bauhaus_slider_set_stop(g->gain_factor, 1.0, 1.0, 1.0, 1.0);
g_object_set(g->gain_factor, "tooltip-text", _("factor of gain"), (char *)NULL);
dt_bauhaus_widget_set_label(g->gain_factor, _("gain"), _("factor"));
g_signal_connect(G_OBJECT(g->gain_factor), "value-changed", G_CALLBACK(gain_factor_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->gain_factor, TRUE, TRUE, 0);
g->gain_r = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->gain[CHANNEL_RED] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->gain_r, 0.0, 0.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->gain_r, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->gain_r, 1.0, 1.0, 0.0, 0.0);
g_object_set(g->gain_r, "tooltip-text", _("factor of red for gain"), (char *)NULL);
dt_bauhaus_widget_set_label(g->gain_r, _("gain"), _("red"));
g_signal_connect(G_OBJECT(g->gain_r), "value-changed", G_CALLBACK(gain_red_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->gain_r, TRUE, TRUE, 0);
g->gain_g = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->gain[CHANNEL_GREEN] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->gain_g, 0.0, 1.0, 0.0, 1.0);
dt_bauhaus_slider_set_stop(g->gain_g, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->gain_g, 1.0, 0.0, 1.0, 0.0);
g_object_set(g->gain_g, "tooltip-text", _("factor of green for gain"), (char *)NULL);
dt_bauhaus_widget_set_label(g->gain_g, _("gain"), _("green"));
g_signal_connect(G_OBJECT(g->gain_g), "value-changed", G_CALLBACK(gain_green_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->gain_g, TRUE, TRUE, 0);
g->gain_b = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.005, p->gain[CHANNEL_BLUE] - 1.0f, 3);
dt_bauhaus_slider_set_stop(g->gain_b, 0.0, 1.0, 1.0, 0.0);
dt_bauhaus_slider_set_stop(g->gain_b, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->gain_b, 1.0, 0.0, 0.0, 1.0);
g_object_set(g->gain_b, "tooltip-text", _("factor of blue for gain"), (char *)NULL);
dt_bauhaus_widget_set_label(g->gain_b, _("gain"), _("blue"));
g_signal_connect(G_OBJECT(g->gain_b), "value-changed", G_CALLBACK(gain_blue_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->gain_b, TRUE, TRUE, 0);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_splittoning_gui_data_t));
dt_iop_splittoning_gui_data_t *g = (dt_iop_splittoning_gui_data_t *)self->gui_data;
dt_iop_splittoning_params_t *p = (dt_iop_splittoning_params_t *)self->params;
int line = 0;
self->widget = gtk_grid_new();
GtkGrid *grid = GTK_GRID(self->widget);
gtk_grid_set_row_spacing(grid, DT_BAUHAUS_SPACE);
gtk_grid_set_column_spacing(grid, DT_BAUHAUS_SPACE);
gtk_grid_set_column_homogeneous(grid, FALSE);
float rgb[3];
// Shadows
hsl2rgb(rgb, p->shadow_hue, p->shadow_saturation, 0.5f);
GdkRGBA sh_color = (GdkRGBA){.red = rgb[0], .green = rgb[1], .blue = rgb[2], .alpha = 1.0 };
line = gui_init_tab(self, line, _("shadows"), &g->colorpick1, &sh_color, &g->gslider1, &g->gslider2);
// Highlights
hsl2rgb(rgb, p->highlight_hue, p->highlight_saturation, 0.5f);
GdkRGBA hi_color = (GdkRGBA){.red = rgb[0], .green = rgb[1], .blue = rgb[2], .alpha = 1.0 };
line = gui_init_tab(self, line, _("highlights"), &g->colorpick2, &hi_color, &g->gslider3, &g->gslider4);
// Additional parameters
g->scale1 = dt_bauhaus_slider_new_with_range_and_feedback(self, 0.0, 100.0, 0.1, p->balance * 100.0, 2, 0);
dt_bauhaus_slider_set_format(g->scale1, "%.2f");
dt_bauhaus_slider_set_stop(g->scale1, 0.0f, 0.5f, 0.5f, 0.5f);
dt_bauhaus_slider_set_stop(g->scale1, 1.0f, 0.5f, 0.5f, 0.5f);
dt_bauhaus_widget_set_label(g->scale1, NULL, _("balance"));
gtk_widget_set_margin_top(g->scale1, 6 * DT_BAUHAUS_SPACE);
gtk_grid_attach(grid, g->scale1, 0, line++, 2, 1);
g->scale2 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->compress, 2);
dt_bauhaus_slider_set_format(g->scale2, "%.2f%%");
dt_bauhaus_widget_set_label(g->scale2, NULL, _("compress"));
gtk_grid_attach(grid, g->scale2, 0, line++, 2, 1);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the balance of center of splittoning"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text",
_("compress the effect on highlights/shadows and\npreserve midtones"), (char *)NULL);
g_signal_connect(G_OBJECT(g->gslider1), "value-changed", G_CALLBACK(hue_callback), self);
g_signal_connect(G_OBJECT(g->gslider3), "value-changed", G_CALLBACK(hue_callback), self);
g_signal_connect(G_OBJECT(g->gslider2), "value-changed", G_CALLBACK(saturation_callback), self);
g_signal_connect(G_OBJECT(g->gslider4), "value-changed", G_CALLBACK(saturation_callback), self);
g_signal_connect(G_OBJECT(g->scale1), "value-changed", G_CALLBACK(balance_callback), self);
g_signal_connect(G_OBJECT(g->scale2), "value-changed", G_CALLBACK(compress_callback), self);
g_signal_connect(G_OBJECT(g->colorpick1), "color-set", G_CALLBACK(colorpick_callback), self);
g_signal_connect(G_OBJECT(g->colorpick2), "color-set", G_CALLBACK(colorpick_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_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(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_splittoning_gui_data_t));
dt_iop_splittoning_gui_data_t *g = (dt_iop_splittoning_gui_data_t *)self->gui_data;
dt_iop_splittoning_params_t *p = (dt_iop_splittoning_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, 0));
// Shadows
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(dtgtk_label_new(_("shadows"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT)), FALSE, FALSE, 5);
g->colorpick1 = 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->colorpick1),32,32);
GtkWidget *hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox1 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_end(GTK_BOX(hbox),GTK_WIDGET(g->colorpick1),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->label1 = dtgtk_reset_label_new (_("hue"), self, &p->shadow_hue, sizeof(float));
g->label2 = dtgtk_reset_label_new (_("saturation"), self, &p->shadow_saturation, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label2), TRUE, TRUE, 0);
int lightness=32768;
g->gslider1=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,0,0
},(GdkColor)
{
0,lightness,0,0
}));
dtgtk_gradient_slider_set_stop(g->gslider1,0.166,(GdkColor)
{
0,lightness,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.332,(GdkColor)
{
0,0,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.498,(GdkColor)
{
0,0,lightness,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.664,(GdkColor)
{
0,0,0,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.83,(GdkColor)
{
0,lightness,0,lightness
});
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider1), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider1), "tooltip-text", _("select the hue tone for shadows"), (char *)NULL);
g->gslider2=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,lightness,lightness
},(GdkColor)
{
0,lightness,lightness,lightness
}));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider2), "tooltip-text", _("select the saturation shadow tone"), (char *)NULL);
// Highlights
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(dtgtk_label_new(_("highlights"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT)), FALSE, FALSE, 5);
g->colorpick2 = 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->colorpick2),32,32);
hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox1 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_end(GTK_BOX(hbox),GTK_WIDGET(g->colorpick2),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->label3 = dtgtk_reset_label_new (_("hue"), self, &p->highlight_hue, sizeof(float));
g->label4 = dtgtk_reset_label_new (_("saturation"), self, &p->highlight_saturation, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label3), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label4), TRUE, TRUE, 0);
g->gslider3=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,0,0
},(GdkColor)
{
0,lightness,0,0
}));
dtgtk_gradient_slider_set_stop(g->gslider3,0.166,(GdkColor)
{
0,lightness,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.332,(GdkColor)
{
0,0,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.498,(GdkColor)
{
0,0,lightness,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.664,(GdkColor)
{
0,0,0,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.83,(GdkColor)
{
0,lightness,0,lightness
});
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider3), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider3), "tooltip-text", _("select the hue tone for highlights"), (char *)NULL);
g->gslider4=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,lightness,lightness
},(GdkColor)
{
0,lightness,lightness,lightness
}));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider4), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider4), "tooltip-text", _("select the saturation highlights tone"), (char *)NULL);
// Additional paramters
hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->scale1 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.1, p->balance*100.0, 2);
dt_bauhaus_slider_set_format(g->scale1, "%.2f");
dt_bauhaus_widget_set_label(g->scale1, _("balance"));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
g->scale2 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->compress, 2);
dt_bauhaus_slider_set_format(g->scale2, "%.2f%%");
dt_bauhaus_widget_set_label(g->scale2,_("compress"));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the balance of center of splittoning"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("compress the effect on highlighs/shadows and\npreserve midtones"), (char *)NULL);
g_signal_connect (G_OBJECT (g->gslider1), "value-changed",
G_CALLBACK (hue_callback), self);
g_signal_connect (G_OBJECT (g->gslider3), "value-changed",
G_CALLBACK (hue_callback), self);
g_signal_connect (G_OBJECT (g->gslider2), "value-changed",
G_CALLBACK (saturation_callback), self);
g_signal_connect (G_OBJECT (g->gslider4), "value-changed",
G_CALLBACK (saturation_callback), self);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (balance_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (compress_callback), self);
g_signal_connect (G_OBJECT (g->colorpick1), "clicked",
G_CALLBACK (colorpick_callback), self);
g_signal_connect (G_OBJECT (g->colorpick2), "clicked",
G_CALLBACK (colorpick_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_colorchecker_gui_data_t));
dt_iop_colorchecker_gui_data_t *g = (dt_iop_colorchecker_gui_data_t *)self->gui_data;
dt_iop_colorchecker_params_t *p = (dt_iop_colorchecker_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
// custom 24-patch widget in addition to combo box
g->area = dtgtk_drawing_area_new_with_aspect_ratio(4.0/6.0);
gtk_box_pack_start(GTK_BOX(self->widget), g->area, TRUE, TRUE, 0);
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 | GDK_SCROLL_MASK);
g_signal_connect(G_OBJECT(g->area), "draw", G_CALLBACK(checker_draw), self);
g_signal_connect(G_OBJECT(g->area), "button-press-event", G_CALLBACK(checker_button_press), self);
g_signal_connect(G_OBJECT(g->area), "motion-notify-event", G_CALLBACK(checker_motion_notify), self);
g_signal_connect(G_OBJECT(g->area), "leave-notify-event", G_CALLBACK(checker_leave_notify), self);
g->patch = 0;
g->drawn_patch = -1;
g->combobox_patch = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->combobox_patch, NULL, _("patch"));
gtk_widget_set_tooltip_text(g->combobox_patch, _("color checker patch"));
char cboxentry[1024];
for(int k=0;k<p->num_patches;k++)
{
snprintf(cboxentry, sizeof(cboxentry), _("patch #%d"), k);
dt_bauhaus_combobox_add(g->combobox_patch, cboxentry);
}
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
dt_bauhaus_widget_set_quad_paint(g->combobox_patch, dtgtk_cairo_paint_colorpicker, CPF_ACTIVE);
g->scale_L = dt_bauhaus_slider_new_with_range(self, -100.0, 100.0, 1.0, 0.0f, 2);
gtk_widget_set_tooltip_text(g->scale_L, _("lightness offset"));
dt_bauhaus_widget_set_label(g->scale_L, NULL, _("lightness"));
g->scale_a = dt_bauhaus_slider_new_with_range(self, -256.0, 256.0, 1.0, 0.0f, 2);
gtk_widget_set_tooltip_text(g->scale_a, _("chroma offset green/red"));
dt_bauhaus_widget_set_label(g->scale_a, NULL, _("green/red"));
dt_bauhaus_slider_set_stop(g->scale_a, 0.0, 0.0, 1.0, 0.2);
dt_bauhaus_slider_set_stop(g->scale_a, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->scale_a, 1.0, 1.0, 0.0, 0.2);
g->scale_b = dt_bauhaus_slider_new_with_range(self, -256.0, 256.0, 1.0, 0.0f, 2);
gtk_widget_set_tooltip_text(g->scale_b, _("chroma offset blue/yellow"));
dt_bauhaus_widget_set_label(g->scale_b, NULL, _("blue/yellow"));
dt_bauhaus_slider_set_stop(g->scale_b, 0.0, 0.0, 0.0, 1.0);
dt_bauhaus_slider_set_stop(g->scale_b, 0.5, 1.0, 1.0, 1.0);
dt_bauhaus_slider_set_stop(g->scale_b, 1.0, 1.0, 1.0, 0.0);
g->scale_C = dt_bauhaus_slider_new_with_range(self, -128.0, 128.0, 1.0f, 0.0f, 2);
gtk_widget_set_tooltip_text(g->scale_C, _("saturation offset"));
dt_bauhaus_widget_set_label(g->scale_C, NULL, _("saturation"));
gtk_box_pack_start(GTK_BOX(self->widget), g->combobox_patch, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_L, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_a, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_b, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_C, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(g->combobox_patch), "value-changed", G_CALLBACK(patch_callback), self);
g_signal_connect(G_OBJECT(g->combobox_patch), "quad-pressed", G_CALLBACK(picker_callback), self);
g_signal_connect(G_OBJECT(g->scale_L), "value-changed", G_CALLBACK(target_L_callback), self);
g_signal_connect(G_OBJECT(g->scale_a), "value-changed", G_CALLBACK(target_a_callback), self);
g_signal_connect(G_OBJECT(g->scale_b), "value-changed", G_CALLBACK(target_b_callback), self);
g_signal_connect(G_OBJECT(g->scale_C), "value-changed", G_CALLBACK(target_C_callback), self);
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(dt_iop_module_t *self)
{
// init the slider (more sophisticated layouts are possible with gtk tables and boxes):
self->gui_data = malloc(sizeof(dt_iop_bilat_gui_data_t));
dt_iop_bilat_gui_data_t *g = (dt_iop_bilat_gui_data_t *)self->gui_data;
memset(&g->ll_boundary, 0, sizeof(local_laplacian_boundary_t));
dt_pthread_mutex_init(&g->lock, NULL);
g->hash = 0;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
g->mode = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->mode, NULL, _("mode"));
gtk_box_pack_start(GTK_BOX(self->widget), g->mode, TRUE, TRUE, 0);
dt_bauhaus_combobox_add(g->mode, _("bilateral grid"));
dt_bauhaus_combobox_add(g->mode, _("local laplacian filter"));
dt_bauhaus_combobox_set_default(g->mode, s_mode_local_laplacian);
dt_bauhaus_combobox_set(g->mode, s_mode_local_laplacian);
gtk_widget_set_tooltip_text(g->mode, _("the filter used for local contrast enhancement. bilateral is faster but can lead to artifacts around edges for extreme settings."));
g->detail = dt_bauhaus_slider_new_with_range(self, 0.0, 500.0, 1.0, 120.0, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->detail, TRUE, TRUE, 0);
dt_bauhaus_widget_set_label(g->detail, NULL, _("detail"));
dt_bauhaus_slider_set_format(g->detail, "%.0f%%");
gtk_widget_set_tooltip_text(g->detail, _("changes the local contrast"));
g->spatial = dt_bauhaus_slider_new_with_range(self, 1, 100, 1, 50, 0);
dt_bauhaus_widget_set_label(g->spatial, NULL, _("coarseness"));
gtk_box_pack_start(GTK_BOX(self->widget), g->spatial, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(g->spatial, _("feature size of local details (spatial sigma of bilateral filter)"));
g->range = dt_bauhaus_slider_new_with_range(self, 1, 100, 1, 20, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->range, TRUE, TRUE, 0);
dt_bauhaus_widget_set_label(g->range, NULL, _("contrast"));
gtk_widget_set_tooltip_text(g->range, _("L difference to detect edges (range sigma of bilateral filter)"));
g->highlights = dt_bauhaus_slider_new_with_range(self, 0.0, 200.0, 1.0, 100.0, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->highlights, TRUE, TRUE, 0);
dt_bauhaus_widget_set_label(g->highlights, NULL, _("highlights"));
dt_bauhaus_slider_set_format(g->highlights, "%.0f%%");
gtk_widget_set_tooltip_text(g->highlights, _("changes the local contrast of highlights"));
g->shadows = dt_bauhaus_slider_new_with_range(self, 0.0, 200.0, 1.0, 100.0, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->shadows, TRUE, TRUE, 0);
dt_bauhaus_widget_set_label(g->shadows, NULL, _("shadows"));
gtk_widget_set_tooltip_text(g->shadows, _("changes the local contrast of shadows"));
dt_bauhaus_slider_set_format(g->shadows, "%.0f%%");
g->midtone = dt_bauhaus_slider_new_with_range(self, 0.001, 1.0, 0.001, 0.2, 3);
gtk_box_pack_start(GTK_BOX(self->widget), g->midtone, TRUE, TRUE, 0);
dt_bauhaus_widget_set_label(g->midtone, NULL, _("midtone range"));
gtk_widget_set_tooltip_text(g->midtone, _("defines what counts as midtones. lower for better dynamic range compression (reduce shadow and highlight contrast), increase for more powerful local contrast"));
// work around multi-instance issue which calls show all a fair bit:
g_object_set(G_OBJECT(g->highlights), "no-show-all", TRUE, NULL);
g_object_set(G_OBJECT(g->shadows), "no-show-all", TRUE, NULL);
g_object_set(G_OBJECT(g->midtone), "no-show-all", TRUE, NULL);
g_object_set(G_OBJECT(g->range), "no-show-all", TRUE, NULL);
g_object_set(G_OBJECT(g->spatial), "no-show-all", TRUE, NULL);
g_signal_connect(G_OBJECT(g->spatial), "value-changed", G_CALLBACK(spatial_callback), self);
g_signal_connect(G_OBJECT(g->range), "value-changed", G_CALLBACK(range_callback), self);
g_signal_connect(G_OBJECT(g->detail), "value-changed", G_CALLBACK(detail_callback), self);
g_signal_connect(G_OBJECT(g->highlights), "value-changed", G_CALLBACK(highlights_callback), self);
g_signal_connect(G_OBJECT(g->shadows), "value-changed", G_CALLBACK(shadows_callback), self);
g_signal_connect(G_OBJECT(g->midtone), "value-changed", G_CALLBACK(midtone_callback), self);
g_signal_connect(G_OBJECT(g->mode), "value-changed", G_CALLBACK(mode_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_splittoning_gui_data_t));
dt_iop_splittoning_gui_data_t *g = (dt_iop_splittoning_gui_data_t *)self->gui_data;
dt_iop_splittoning_params_t *p = (dt_iop_splittoning_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE));
float rgb[3];
// Shadows
hsl2rgb(rgb, p->shadow_hue, p->shadow_saturation, 0.5f);
GdkRGBA sh_color = (GdkRGBA){.red = rgb[0], .green = rgb[1], .blue = rgb[2], .alpha = 1.0 };
gui_init_tab(self, _("shadows"), &g->colorpick1, &sh_color, &g->gslider1, &g->gslider2);
// Highlights
hsl2rgb(rgb, p->highlight_hue, p->highlight_saturation, 0.5f);
GdkRGBA hi_color = (GdkRGBA){.red = rgb[0], .green = rgb[1], .blue = rgb[2], .alpha = 1.0 };
gui_init_tab(self, _("highlights"), &g->colorpick2, &hi_color, &g->gslider3, &g->gslider4);
// Additional parameters
GtkWidget *hbox = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
GtkWidget *vbox = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
g->scale1 = dt_bauhaus_slider_new_with_range_and_feedback(self, 0.0, 100.0, 0.1, p->balance * 100.0, 2, 0);
dt_bauhaus_slider_set_format(g->scale1, "%.2f");
dt_bauhaus_slider_set_stop(g->scale1, 0.0f, 0.5f, 0.5f, 0.5f);
dt_bauhaus_slider_set_stop(g->scale1, 1.0f, 0.5f, 0.5f, 0.5f);
dt_bauhaus_widget_set_label(g->scale1, NULL, _("balance"));
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
g->scale2 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->compress, 2);
dt_bauhaus_slider_set_format(g->scale2, "%.2f%%");
dt_bauhaus_widget_set_label(g->scale2, NULL, _("compress"));
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the balance of center of splittoning"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text",
_("compress the effect on highlights/shadows and\npreserve midtones"), (char *)NULL);
g_signal_connect(G_OBJECT(g->gslider1), "value-changed", G_CALLBACK(hue_callback), self);
g_signal_connect(G_OBJECT(g->gslider3), "value-changed", G_CALLBACK(hue_callback), self);
g_signal_connect(G_OBJECT(g->gslider2), "value-changed", G_CALLBACK(saturation_callback), self);
g_signal_connect(G_OBJECT(g->gslider4), "value-changed", G_CALLBACK(saturation_callback), self);
g_signal_connect(G_OBJECT(g->scale1), "value-changed", G_CALLBACK(balance_callback), self);
g_signal_connect(G_OBJECT(g->scale2), "value-changed", G_CALLBACK(compress_callback), self);
g_signal_connect(G_OBJECT(g->colorpick1), "color-set", G_CALLBACK(colorpick_callback), self);
g_signal_connect(G_OBJECT(g->colorpick2), "color-set", G_CALLBACK(colorpick_callback), self);
}
void gui_cleanup(struct dt_iop_module_t *self)
{
free(self->gui_data);
self->gui_data = NULL;
}
void gui_init(dt_imageio_module_storage_t *self)
{
self->gui_data = (dt_storage_flickr_gui_data_t *)g_malloc0(sizeof(dt_storage_flickr_gui_data_t));
dt_storage_flickr_gui_data_t *ui = self->gui_data;
self->widget = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10));
int line = 0;
GHashTable *table = dt_pwstorage_get("flickr");
gchar *_username = g_strdup(g_hash_table_lookup(table, "username"));
g_hash_table_destroy(table);
GtkWidget *hbox, *label, *button;
label = gtk_label_new(_("flickr user"));
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
ui->user_entry = GTK_ENTRY(gtk_entry_new());
gtk_widget_set_hexpand(GTK_WIDGET(ui->user_entry), TRUE);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->user_entry));
gtk_entry_set_text(ui->user_entry, _username == NULL ? "" : _username);
g_signal_connect(G_OBJECT(ui->user_entry), "changed", G_CALLBACK(flickr_entry_changed), (gpointer)ui);
gtk_entry_set_width_chars(GTK_ENTRY(ui->user_entry), 0);
button = gtk_button_new_with_label(_("login"));
g_object_set(G_OBJECT(button), "tooltip-text", _("flickr login"), (char *)NULL);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->user_entry), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_grid_attach_next_to(GTK_GRID(self->widget), hbox, label, GTK_POS_RIGHT, 1, 1);
ui->status_label = GTK_LABEL(gtk_label_new(NULL));
gtk_widget_set_halign(GTK_WIDGET(ui->status_label), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(ui->status_label), 1, line++, 1, 1);
ui->export_tags = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->export_tags, NULL, _("export tags"));
dt_bauhaus_combobox_add(ui->export_tags, _("yes"));
dt_bauhaus_combobox_add(ui->export_tags, _("no"));
dt_bauhaus_combobox_set(ui->export_tags, 0);
gtk_widget_set_hexpand(ui->export_tags, TRUE);
gtk_grid_attach(GTK_GRID(self->widget), ui->export_tags, 0, line++, 2, 1);
ui->permission_list = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->permission_list, NULL, _("visible to"));
dt_bauhaus_combobox_add(ui->permission_list, _("you"));
dt_bauhaus_combobox_add(ui->permission_list, _("friends"));
dt_bauhaus_combobox_add(ui->permission_list, _("family"));
dt_bauhaus_combobox_add(ui->permission_list, _("friends + family"));
dt_bauhaus_combobox_add(ui->permission_list, _("everyone"));
dt_bauhaus_combobox_set(ui->permission_list, 0); // Set default permission to private
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(ui->permission_list), 0, line++, 2, 1);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5));
ui->album_list = dt_bauhaus_combobox_new(NULL); // Available albums
dt_bauhaus_widget_set_label(ui->album_list, NULL, _("photosets"));
g_signal_connect(G_OBJECT(ui->album_list), "value-changed", G_CALLBACK(flickr_album_changed), (gpointer)ui);
gtk_widget_set_sensitive(ui->album_list, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), ui->album_list, TRUE, TRUE, 0);
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_DO_NOT_USE_BORDER);
g_object_set(G_OBJECT(button), "tooltip-text", _("refresh album list"), (char *)NULL);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(self->widget), hbox, 0, line++, 2, 1);
// the box that gets shown when a new album is to be created
ui->create_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5)));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->create_box), TRUE);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(ui->create_box), 0, line++, 2, 1);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
label = gtk_label_new(_("title"));
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
ui->title_entry = GTK_ENTRY(gtk_entry_new()); // Album title
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->title_entry));
gtk_entry_set_text(ui->title_entry, _("my new photoset"));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->title_entry), TRUE, TRUE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(ui->title_entry), 0);
gtk_box_pack_start(ui->create_box, hbox, FALSE, FALSE, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
label = gtk_label_new(_("summary"));
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
ui->summary_entry = GTK_ENTRY(gtk_entry_new()); // Album summary
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->summary_entry));
gtk_entry_set_text(ui->summary_entry, _("exported from darktable"));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->summary_entry), TRUE, TRUE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(ui->summary_entry), 0);
gtk_box_pack_start(ui->create_box, hbox, TRUE, TRUE, 0);
set_status(ui, _("click login button to start"), "#ffffff");
/**
don't populate the combo on startup, save 3 second
// If username and password is stored, let's populate the combo
if( _username && _password )
{
ui->user_token = _password;
refresh_albums(ui);
}
*/
g_free(_username);
dt_bauhaus_combobox_set(ui->album_list, 0);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_colorize_gui_data_t));
dt_iop_colorize_gui_data_t *g = (dt_iop_colorize_gui_data_t *)self->gui_data;
dt_iop_colorize_params_t *p = (dt_iop_colorize_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, 0));
g->colorpick1 = 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->colorpick1),32,32);
GtkWidget *hbox = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox1 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_end(GTK_BOX(hbox),GTK_WIDGET(g->colorpick1),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->label1 = dtgtk_reset_label_new (_("hue"), self, &p->hue, sizeof(float));
g->label2 = dtgtk_reset_label_new (_("saturation"), self, &p->saturation, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label2), TRUE, TRUE, 0);
int lightness=32768;
g->gslider1 = DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,0,0
},(GdkColor)
{
0,lightness,0,0
}));
dtgtk_gradient_slider_set_stop(g->gslider1,0.166,(GdkColor)
{
0,lightness,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.332,(GdkColor)
{
0,0,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.498,(GdkColor)
{
0,0,lightness,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.664,(GdkColor)
{
0,0,0,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.83,(GdkColor)
{
0,lightness,0,lightness
});
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider1), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider1), "tooltip-text", _("select the hue tone"), (char *)NULL);
g->gslider2=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,lightness,lightness
},(GdkColor)
{
0,lightness,lightness,lightness
}));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider2), "tooltip-text", _("select the saturation shadow tone"), (char *)NULL);
// Additional paramters
hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->scale1 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.1, p->lightness*100.0, 2);
dt_bauhaus_slider_set_format(g->scale1, "%.2f%%");
dt_bauhaus_widget_set_label(g->scale1, _("lightness"));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
g->scale2 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.1, p->source_lightness_mix, 2);
dt_bauhaus_slider_set_format(g->scale2, "%.2f%%");
dt_bauhaus_widget_set_label(g->scale2, _("source mix"));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("lightness of color"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("mix value of source lightness"), (char *)NULL);
g_signal_connect (G_OBJECT (g->gslider1), "value-changed",
G_CALLBACK (hue_callback), self);
g_signal_connect (G_OBJECT (g->gslider2), "value-changed",
G_CALLBACK (saturation_callback), self);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (lightness_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (source_lightness_mix_callback), self);
g_signal_connect (G_OBJECT (g->colorpick1), "clicked",
G_CALLBACK (colorpick_callback), self);
}
void gui_init (struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_temperature_gui_data_t));
dt_iop_temperature_gui_data_t *g = (dt_iop_temperature_gui_data_t *)self->gui_data;
dt_iop_temperature_params_t *p = (dt_iop_temperature_params_t*)self->default_params;
self->request_color_pick = 0;
self->widget = gtk_vbox_new(TRUE, DT_BAUHAUS_SPACE);
g_signal_connect(G_OBJECT(self->widget), "expose-event", G_CALLBACK(expose), self);
g->scale_tint = dt_bauhaus_slider_new_with_range(self,0.1, 8.0, .01,1.0,3);
g->scale_k = dt_bauhaus_slider_new_with_range(self,DT_IOP_LOWEST_TEMPERATURE, DT_IOP_HIGHEST_TEMPERATURE, 10.,5000.0,0);
g->scale_k_out = dt_bauhaus_slider_new_with_range(self,DT_IOP_LOWEST_TEMPERATURE, DT_IOP_HIGHEST_TEMPERATURE, 10.,5000.0,0);
g->scale_r = dt_bauhaus_slider_new_with_range(self,0.0, 8.0, .001,p->coeffs[0],3);
g->scale_g = dt_bauhaus_slider_new_with_range(self,0.0, 8.0, .001,p->coeffs[1],3);
g->scale_b = dt_bauhaus_slider_new_with_range(self,0.0, 8.0, .001,p->coeffs[2],3);
dt_bauhaus_slider_set_format(g->scale_k,"%.0fK");
dt_bauhaus_slider_set_format(g->scale_k_out,"%.0fK");
dt_bauhaus_widget_set_label(g->scale_tint,_("tint"));
dt_bauhaus_widget_set_label(g->scale_k,_("temperature in"));
dt_bauhaus_widget_set_label(g->scale_k_out,_("temperature out"));
dt_bauhaus_widget_set_label(g->scale_r,_("red"));
dt_bauhaus_widget_set_label(g->scale_g,_("green"));
dt_bauhaus_widget_set_label(g->scale_b,_("blue"));
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_tint, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_k, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_k_out, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_r, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_g, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_b, TRUE, TRUE, 0);
g->presets = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->presets,_("preset"));
dt_bauhaus_combobox_add(g->presets, _("camera white balance"));
dt_bauhaus_combobox_add(g->presets, _("spot white balance"));
dt_bauhaus_combobox_add(g->presets, _("passthrough"));
g->preset_cnt = 3;
const char *wb_name = NULL;
char makermodel[1024];
char *model = makermodel;
dt_colorspaces_get_makermodel_split(makermodel, 1024, &model, self->dev->image_storage.exif_maker, self->dev->image_storage.exif_model);
if(!dt_image_is_ldr(&self->dev->image_storage)) for(int i=0; i<wb_preset_count; i++)
{
if(g->preset_cnt >= 50) break;
if(!strcmp(wb_preset[i].make, makermodel) &&
!strcmp(wb_preset[i].model, model))
{
if(!wb_name || strcmp(wb_name, wb_preset[i].name))
{
wb_name = wb_preset[i].name;
dt_bauhaus_combobox_add(g->presets, _(wb_preset[i].name));
g->preset_num[g->preset_cnt++] = i;
}
}
}
gtk_box_pack_start(GTK_BOX(self->widget), g->presets, TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->presets), "tooltip-text", _("choose white balance preset from camera"), (char *)NULL);
g->finetune = dt_bauhaus_slider_new_with_range(self,-9.0, 9.0, 1.0, 0.0, 0);
dt_bauhaus_widget_set_label(g->finetune, _("finetune"));
dt_bauhaus_slider_set_format(g->finetune, _("%.0f mired"));
// initially doesn't have fine tuning stuff (camera wb)
gtk_widget_set_sensitive(g->finetune, FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), g->finetune, TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->finetune), "tooltip-text", _("fine tune white balance preset"), (char *)NULL);
self->gui_update(self);
g_signal_connect (G_OBJECT (g->scale_tint), "value-changed",
G_CALLBACK (tint_callback), self);
g_signal_connect (G_OBJECT (g->scale_k), "value-changed",
G_CALLBACK (temp_callback), self);
g_signal_connect (G_OBJECT (g->scale_k_out), "value-changed",
G_CALLBACK (temp_out_callback), self);
g_signal_connect (G_OBJECT (g->scale_r), "value-changed",
G_CALLBACK (rgb_callback), self);
g_signal_connect (G_OBJECT (g->scale_g), "value-changed",
G_CALLBACK (rgb_callback), self);
g_signal_connect (G_OBJECT (g->scale_b), "value-changed",
G_CALLBACK (rgb_callback), self);
g_signal_connect (G_OBJECT (g->presets), "value-changed",
G_CALLBACK (presets_changed), self);
g_signal_connect (G_OBJECT (g->finetune), "value-changed",
G_CALLBACK (finetune_changed), self);
}
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_exposure_gui_data_t));
dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data;
dt_iop_exposure_params_t *p = (dt_iop_exposure_params_t *)self->params;
g->modes = NULL;
g->deflicker_histogram_sources = NULL;
g->deflicker_histogram = NULL;
dt_pthread_mutex_init(&g->lock, NULL);
/* register hooks with current dev so that histogram
can interact with this module.
*/
darktable.develop->proxy.exposure.module = self;
darktable.develop->proxy.exposure.set_white = dt_iop_exposure_set_white;
darktable.develop->proxy.exposure.get_white = dt_iop_exposure_get_white;
darktable.develop->proxy.exposure.set_black = dt_iop_exposure_set_black;
darktable.develop->proxy.exposure.get_black = dt_iop_exposure_get_black;
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
self->widget = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE));
g->mode = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->mode, NULL, _("mode"));
dt_bauhaus_combobox_add(g->mode, C_("mode", "manual"));
g->modes = g_list_append(g->modes, GUINT_TO_POINTER(EXPOSURE_MODE_MANUAL));
dt_bauhaus_combobox_add(g->mode, _("automatic"));
g->modes = g_list_append(g->modes, GUINT_TO_POINTER(EXPOSURE_MODE_DEFLICKER));
dt_bauhaus_combobox_set_default(g->mode, 0);
dt_bauhaus_combobox_set(g->mode, g_list_index(g->modes, GUINT_TO_POINTER(p->mode)));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->mode), TRUE, TRUE, 0);
g->black = dt_bauhaus_slider_new_with_range(self, -0.1, 0.1, .001, p->black, 4);
g_object_set(G_OBJECT(g->black), "tooltip-text", _("adjust the black level"), (char *)NULL);
dt_bauhaus_slider_set_format(g->black, "%.4f");
dt_bauhaus_widget_set_label(g->black, NULL, _("black"));
dt_bauhaus_slider_enable_soft_boundaries(g->black, -1.0, 1.0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->black), TRUE, TRUE, 0);
g->mode_stack = gtk_stack_new();
gtk_stack_set_homogeneous(GTK_STACK(g->mode_stack),FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), g->mode_stack, TRUE, TRUE, 0);
GtkWidget *vbox_manual = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE));
g->exposure = dt_bauhaus_slider_new_with_range(self, -3.0, 3.0, .02, p->exposure, 3);
g_object_set(G_OBJECT(g->exposure), "tooltip-text", _("adjust the exposure correction"), (char *)NULL);
dt_bauhaus_slider_set_format(g->exposure, "%.2fEV");
dt_bauhaus_widget_set_label(g->exposure, NULL, _("exposure"));
dt_bauhaus_slider_enable_soft_boundaries(g->exposure, -18.0, 18.0);
gtk_box_pack_start(GTK_BOX(vbox_manual), GTK_WIDGET(g->exposure), TRUE, TRUE, 0);
GtkBox *hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
g->autoexp = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("auto")));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoexp), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexp), FALSE, TRUE, 0);
g->autoexpp = dt_bauhaus_slider_new_with_range(self, 0.0, 0.2, .001, 0.01, 3);
g_object_set(G_OBJECT(g->autoexpp), "tooltip-text", _("percentage of bright values clipped out"),
(char *)NULL);
gtk_widget_set_sensitive(GTK_WIDGET(g->autoexpp), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexpp), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_manual), GTK_WIDGET(hbox), TRUE, TRUE, 0);
gtk_widget_show_all(vbox_manual);
gtk_stack_add_named(GTK_STACK(g->mode_stack), vbox_manual, "manual");
GtkWidget *vbox_deflicker = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE));
g->deflicker_percentile = dt_bauhaus_slider_new_with_range(self, 0, 100, .01, p->deflicker_percentile, 3);
// FIXME: this needs a better tooltip!
g_object_set(G_OBJECT(g->deflicker_percentile), "tooltip-text", _("percentile"), (char *)NULL);
dt_bauhaus_slider_set_format(g->deflicker_percentile, "%.2f%%");
dt_bauhaus_widget_set_label(g->deflicker_percentile, NULL, _("percentile"));
gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(g->deflicker_percentile), TRUE, TRUE, 0);
g->deflicker_target_level
= dt_bauhaus_slider_new_with_range(self, -18.0, 18.0, .01, p->deflicker_target_level, 3);
g_object_set(G_OBJECT(g->deflicker_target_level), "tooltip-text", _("target level"), (char *)NULL);
dt_bauhaus_slider_set_format(g->deflicker_target_level, "%.2fEV");
dt_bauhaus_widget_set_label(g->deflicker_target_level, NULL, _("target level"));
gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(g->deflicker_target_level), TRUE, TRUE, 0);
g->deflicker_histogram_source = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->deflicker_histogram_source, NULL, _("histogram of"));
dt_bauhaus_combobox_add(g->deflicker_histogram_source, _("pre-processed image"));
g->deflicker_histogram_sources
= g_list_append(g->deflicker_histogram_sources, GUINT_TO_POINTER(DEFLICKER_HISTOGRAM_SOURCE_THUMBNAIL));
dt_bauhaus_combobox_add(g->deflicker_histogram_source, _("source raw data"));
g->deflicker_histogram_sources = g_list_append(g->deflicker_histogram_sources,
GUINT_TO_POINTER(DEFLICKER_HISTOGRAM_SOURCE_SOURCEFILE));
dt_bauhaus_combobox_set_default(g->deflicker_histogram_source, DEFLICKER_HISTOGRAM_SOURCE_THUMBNAIL);
dt_bauhaus_combobox_set(g->deflicker_histogram_source,
g_list_index(g->modes, GUINT_TO_POINTER(p->deflicker_histogram_source)));
gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(g->deflicker_histogram_source), TRUE, TRUE, 0);
GtkBox *hbox1 = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
GtkLabel *label = GTK_LABEL(gtk_label_new(_("computed EC: ")));
gtk_box_pack_start(GTK_BOX(hbox1), GTK_WIDGET(label), FALSE, FALSE, 0);
g->deflicker_used_EC = GTK_LABEL(gtk_label_new("")); // This gets filled in by process
g_object_set(G_OBJECT(g->deflicker_used_EC), "tooltip-text",
_("what exposure correction have actually been used"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(hbox1), GTK_WIDGET(g->deflicker_used_EC), FALSE, FALSE, 0);
dt_pthread_mutex_lock(&g->lock);
g->deflicker_computed_exposure = NAN;
dt_pthread_mutex_unlock(&g->lock);
gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(hbox1), FALSE, FALSE, 0);
gtk_widget_show_all(vbox_deflicker);
gtk_stack_add_named(GTK_STACK(g->mode_stack), vbox_deflicker, "deflicker");
g_signal_connect(G_OBJECT(g->mode), "value-changed", G_CALLBACK(mode_callback), self);
g_signal_connect(G_OBJECT(g->black), "value-changed", G_CALLBACK(black_callback), self);
g_signal_connect(G_OBJECT(g->exposure), "value-changed", G_CALLBACK(exposure_callback), self);
g_signal_connect(G_OBJECT(g->autoexpp), "value-changed", G_CALLBACK(autoexpp_callback), self);
g_signal_connect(G_OBJECT(g->autoexp), "toggled", G_CALLBACK(autoexp_callback), self);
g_signal_connect(G_OBJECT(g->deflicker_percentile), "value-changed", G_CALLBACK(deflicker_params_callback),
self);
g_signal_connect(G_OBJECT(g->deflicker_target_level), "value-changed",
G_CALLBACK(deflicker_params_callback), self);
g_signal_connect(G_OBJECT(g->deflicker_histogram_source), "value-changed",
G_CALLBACK(deflicker_histogram_source_callback), self);
g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(draw), self);
}
void dt_iop_gui_init_blending(GtkWidget *iopw, dt_iop_module_t *module)
{
/* create and add blend mode if module supports it */
if (module->flags()&IOP_FLAGS_SUPPORTS_BLENDING)
{
module->blend_data = g_malloc(sizeof(dt_iop_gui_blend_data_t));
memset(module->blend_data, 0, sizeof(dt_iop_gui_blend_data_t));
dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t*)module->blend_data;
dt_iop_gui_blendop_modes_t modes[23]; /* number must fit exactly!!! */
modes[0].mode = DEVELOP_BLEND_DISABLED;
modes[0].name = _("off");
modes[1].mode = DEVELOP_BLEND_NORMAL;
modes[1].name = _("normal");
modes[2].mode = DEVELOP_BLEND_INVERSE;
modes[2].name = _("inverse");
modes[3].mode = DEVELOP_BLEND_LIGHTEN;
modes[3].name = _("lighten");
modes[4].mode = DEVELOP_BLEND_DARKEN;
modes[4].name = _("darken");
modes[5].mode = DEVELOP_BLEND_MULTIPLY;
modes[5].name = _("multiply");
modes[6].mode = DEVELOP_BLEND_AVERAGE;
modes[6].name = _("average");
modes[7].mode = DEVELOP_BLEND_ADD;
modes[7].name = _("addition");
modes[8].mode = DEVELOP_BLEND_SUBSTRACT;
modes[8].name = _("subtract");
modes[9].mode = DEVELOP_BLEND_DIFFERENCE;
modes[9].name = _("difference");
modes[10].mode = DEVELOP_BLEND_SCREEN;
modes[10].name = _("screen");
modes[11].mode = DEVELOP_BLEND_OVERLAY;
modes[11].name = _("overlay");
modes[12].mode = DEVELOP_BLEND_SOFTLIGHT;
modes[12].name = _("softlight");
modes[13].mode = DEVELOP_BLEND_HARDLIGHT;
modes[13].name = _("hardlight");
modes[14].mode = DEVELOP_BLEND_VIVIDLIGHT;
modes[14].name = _("vividlight");
modes[15].mode = DEVELOP_BLEND_LINEARLIGHT;
modes[15].name = _("linearlight");
modes[16].mode = DEVELOP_BLEND_PINLIGHT;
modes[16].name = _("pinlight");
modes[17].mode = DEVELOP_BLEND_LIGHTNESS;
modes[17].name = _("lightness");
modes[18].mode = DEVELOP_BLEND_CHROMA;
modes[18].name = _("chroma");
modes[19].mode = DEVELOP_BLEND_HUE;
modes[19].name = _("hue");
modes[20].mode = DEVELOP_BLEND_COLOR;
modes[20].name = _("color");
modes[21].mode = DEVELOP_BLEND_COLORADJUST;
modes[21].name = _("coloradjustment");
modes[22].mode = DEVELOP_BLEND_UNBOUNDED;
modes[22].name = _("unbounded");
bd->number_modes = sizeof(modes) / sizeof(dt_iop_gui_blendop_modes_t);
memcpy(bd->modes, modes, bd->number_modes * sizeof(dt_iop_gui_blendop_modes_t));
bd->iopw = iopw;
bd->module = module;
bd->csp = dt_iop_module_colorspace(module);
bd->blendif_support = (bd->csp == iop_cs_Lab || bd->csp == iop_cs_rgb);
bd->blendif_box = NULL;
bd->blend_modes_combo = dt_bauhaus_combobox_new(module);
dt_bauhaus_widget_set_label(bd->blend_modes_combo, _("blend mode"));
bd->opacity_slider = dt_bauhaus_slider_new_with_range(module, 0.0, 100.0, 1, 100.0, 0);
dt_bauhaus_widget_set_label(bd->opacity_slider, _("opacity"));
dt_bauhaus_slider_set_format(bd->opacity_slider, "%.0f%%");
module->fusion_slider = bd->opacity_slider;
for(int k = 0; k < bd->number_modes; k++)
dt_bauhaus_combobox_add(bd->blend_modes_combo, bd->modes[k].name);
dt_bauhaus_combobox_set(bd->blend_modes_combo, 0);
gtk_object_set(GTK_OBJECT(bd->opacity_slider), "tooltip-text", _("set the opacity of the blending"), (char *)NULL);
gtk_object_set(GTK_OBJECT(bd->blend_modes_combo), "tooltip-text", _("choose blending mode"), (char *)NULL);
g_signal_connect (G_OBJECT (bd->opacity_slider), "value-changed",
G_CALLBACK (_blendop_opacity_callback), bd);
g_signal_connect (G_OBJECT (bd->blend_modes_combo), "value-changed",
G_CALLBACK (_blendop_mode_callback), bd);
gtk_box_pack_start(GTK_BOX(iopw), bd->blend_modes_combo, TRUE, TRUE,0);
gtk_box_pack_start(GTK_BOX(iopw), bd->opacity_slider, TRUE, TRUE,0);
if(bd->blendif_support)
{
dt_iop_gui_init_blendif(GTK_VBOX(iopw), module);
}
bd->blend_inited = 1;
gtk_widget_queue_draw(GTK_WIDGET(iopw));
dt_iop_gui_update_blending(module);
}
}
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 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;
}
}
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_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(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 gui_init(dt_imageio_module_storage_t *self)
{
self->gui_data = (dt_storage_piwigo_gui_data_t *)g_malloc0(sizeof(dt_storage_piwigo_gui_data_t));
dt_storage_piwigo_gui_data_t *ui = self->gui_data;
ui->albums = NULL;
ui->accounts = NULL;
ui->api = NULL;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(8));
_piwigo_load_account(ui);
gchar *server = dt_conf_get_string("plugins/imageio/storage/export/piwigo/server");
// look for last server information
_piwigo_account_t *last_account = _piwigo_get_account(ui, server);
GtkWidget *hbox, *label, *button;
// account
ui->account_list = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->account_list, NULL, _("accounts"));
GList *a = ui->accounts;
int account_index = -1, index=0;
while(a)
{
_piwigo_account_t *account = (_piwigo_account_t *)a->data;
dt_bauhaus_combobox_add(ui->account_list, account->server);
if(!strcmp(account->server, server)) account_index = index;
index++;
a = g_list_next(a);
}
gtk_widget_set_hexpand(ui->account_list, TRUE);
g_signal_connect(G_OBJECT(ui->account_list), "value-changed", G_CALLBACK(_piwigo_account_changed), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(self->widget), ui->account_list, FALSE, FALSE, 0);
// server
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
label = gtk_label_new(_("server"));
g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0);
ui->server_entry = GTK_ENTRY(gtk_entry_new());
gtk_widget_set_tooltip_text(GTK_WIDGET(ui->server_entry),
_("the server name\ndefault protocol is https\nspecify http:// if non secure server"));
gtk_widget_set_hexpand(GTK_WIDGET(ui->server_entry), TRUE);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->server_entry));
gtk_entry_set_text(ui->server_entry, last_account?last_account->server:"piwigo.com");
g_signal_connect(G_OBJECT(ui->server_entry), "changed", G_CALLBACK(_piwigo_server_entry_changed), (gpointer)ui);
gtk_entry_set_width_chars(GTK_ENTRY(ui->server_entry), 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(label), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->server_entry), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_free(server);
// login
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
label = gtk_label_new(_("user"));
g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0);
ui->user_entry = GTK_ENTRY(gtk_entry_new());
gtk_widget_set_hexpand(GTK_WIDGET(ui->user_entry), TRUE);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->user_entry));
gtk_entry_set_text(ui->user_entry, last_account?last_account->username:"");
g_signal_connect(G_OBJECT(ui->user_entry), "changed", G_CALLBACK(_piwigo_entry_changed), (gpointer)ui);
gtk_entry_set_width_chars(GTK_ENTRY(ui->user_entry), 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(label), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->user_entry), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
// password
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
label = gtk_label_new(_("password"));
g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0);
ui->pwd_entry = GTK_ENTRY(gtk_entry_new());
gtk_entry_set_visibility(GTK_ENTRY(ui->pwd_entry), FALSE);
gtk_widget_set_hexpand(GTK_WIDGET(ui->pwd_entry), TRUE);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->pwd_entry));
gtk_entry_set_text(ui->pwd_entry, last_account?last_account->password:"");
g_signal_connect(G_OBJECT(ui->pwd_entry), "changed", G_CALLBACK(_piwigo_entry_changed), (gpointer)ui);
gtk_entry_set_width_chars(GTK_ENTRY(ui->pwd_entry), 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(label), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->pwd_entry), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
// login button
button = gtk_button_new_with_label(_("login"));
gtk_widget_set_tooltip_text(button, _("piwigo login"));
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_piwigo_login_clicked), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(self->widget), button, FALSE, FALSE, 0);
// status area
ui->status_label = GTK_LABEL(gtk_label_new(NULL));
gtk_widget_set_halign(GTK_WIDGET(ui->status_label), GTK_ALIGN_START);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->status_label), FALSE, FALSE, 0);
ui->export_tags = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->export_tags, NULL, _("export tags"));
dt_bauhaus_combobox_add(ui->export_tags, _("yes"));
dt_bauhaus_combobox_add(ui->export_tags, _("no"));
dt_bauhaus_combobox_set(ui->export_tags, 0);
gtk_widget_set_hexpand(ui->export_tags, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), ui->export_tags, FALSE, FALSE, 0);
// select account
if(account_index != -1) dt_bauhaus_combobox_set(ui->account_list, account_index);
// permissions list
ui->permission_list = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->permission_list, NULL, _("visible to"));
dt_bauhaus_combobox_add(ui->permission_list, _("everyone"));
dt_bauhaus_combobox_add(ui->permission_list, _("contacts"));
dt_bauhaus_combobox_add(ui->permission_list, _("friends"));
dt_bauhaus_combobox_add(ui->permission_list, _("family"));
dt_bauhaus_combobox_add(ui->permission_list, _("you"));
dt_bauhaus_combobox_set(ui->permission_list, 0); // Set default permission to private
gtk_box_pack_start(GTK_BOX(self->widget), ui->permission_list, FALSE, FALSE, 0);
// album list
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5));
ui->album_list = dt_bauhaus_combobox_new(NULL); // Available albums
dt_bauhaus_widget_set_label(ui->album_list, NULL, _("albums"));
g_signal_connect(G_OBJECT(ui->album_list), "value-changed", G_CALLBACK(_piwigo_album_changed), (gpointer)ui);
gtk_widget_set_sensitive(ui->album_list, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), ui->album_list, TRUE, TRUE, 0);
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_DO_NOT_USE_BORDER, NULL);
gtk_widget_set_tooltip_text(button, _("refresh album list"));
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_piwigo_refresh_clicked), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), hbox, FALSE, FALSE, 0);
// new album
ui->create_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5)));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->create_box), TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->create_box), FALSE, FALSE, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
label = gtk_label_new(_("title"));
g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
ui->new_album_entry = GTK_ENTRY(gtk_entry_new()); // Album title
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->new_album_entry));
gtk_entry_set_text(ui->new_album_entry, _("new album"));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->new_album_entry), TRUE, TRUE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(ui->new_album_entry), 0);
gtk_box_pack_start(ui->create_box, hbox, FALSE, FALSE, 0);
// parent album list
ui->parent_album_list = dt_bauhaus_combobox_new(NULL); // Available albums
dt_bauhaus_widget_set_label(ui->parent_album_list, NULL, _("parent album"));
gtk_widget_set_sensitive(ui->parent_album_list, TRUE);
gtk_box_pack_start(ui->create_box, ui->parent_album_list, TRUE, TRUE, 0);
_piwigo_set_status(ui, _("click login button to start"), "#ffffff");
}
