void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_modulelist_t *d = (dt_lib_modulelist_t *)g_malloc0(sizeof(dt_lib_modulelist_t));
self->data = (void *)d;
self->widget = gtk_scrolled_window_new(
NULL, NULL); // GTK_ADJUSTMENT(gtk_adjustment_new(200, 100, 200, 10, 100, 100))
gtk_widget_set_size_request(self->widget, -1, DT_PIXEL_APPLY_DPI(208));
dt_gui_add_help_link(self->widget, dt_get_help_url(self->plugin_name));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(self->widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
d->tree = GTK_TREE_VIEW(gtk_tree_view_new());
gtk_widget_set_size_request(GTK_WIDGET(d->tree), DT_PIXEL_APPLY_DPI(50), -1);
gtk_container_add(GTK_CONTAINER(self->widget), GTK_WIDGET(d->tree));
gtk_widget_set_name(GTK_WIDGET(self->widget), "lib-modulelist");
/* connect to signal for darktable.develop initialization */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_INITIALIZE,
G_CALLBACK(_lib_modulelist_populate_callback), self);
g_signal_connect(GTK_WIDGET(d->tree), "style-set", G_CALLBACK(_lib_modulelist_style_set), self);
g_signal_connect(GTK_WIDGET(d->tree), "cursor-changed", G_CALLBACK(_lib_modulelist_row_changed_callback),
NULL);
darktable.view_manager->proxy.more_module.module = self;
darktable.view_manager->proxy.more_module.update = _lib_modulelist_gui_update;
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_grain_gui_data_t));
dt_iop_grain_gui_data_t *g = (dt_iop_grain_gui_data_t *)self->gui_data;
dt_iop_grain_params_t *p = (dt_iop_grain_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
dt_gui_add_help_link(self->widget, dt_get_help_url(self->op));
/* courseness */
g->scale1 = dt_bauhaus_slider_new_with_range(self, 20.0, 6400.0, 20.0, p->scale * GRAIN_SCALE_FACTOR, 0);
dt_bauhaus_widget_set_label(g->scale1, NULL, _("coarseness"));
dt_bauhaus_slider_set_format(g->scale1, "%.0fISO");
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(g->scale1, _("the grain size (~ISO of the film)"));
g_signal_connect(G_OBJECT(g->scale1), "value-changed", G_CALLBACK(scale_callback), self);
/* strength */
g->scale2 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->strength, 2);
dt_bauhaus_widget_set_label(g->scale2, NULL, _("strength"));
dt_bauhaus_slider_set_format(g->scale2, "%.0f%%");
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(g->scale2, _("the strength of applied grain"));
g_signal_connect(G_OBJECT(g->scale2), "value-changed", G_CALLBACK(strength_callback), self);
/* midtones bias */
g->scale3 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->midtones_bias, 2);
dt_bauhaus_widget_set_label(g->scale3, NULL, _("midtones bias"));
dt_bauhaus_slider_set_format(g->scale3, "%.0f%%");
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale3), TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(g->scale3, _("amount of midtones bias from the photographic paper response modeling. the greater the bias, the more pronounced the fall off of the grain in shadows and highlights"));
g_signal_connect(G_OBJECT(g->scale3), "value-changed", G_CALLBACK(midtones_bias_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_rlce_gui_data_t));
dt_iop_rlce_gui_data_t *g = (dt_iop_rlce_gui_data_t *)self->gui_data;
dt_iop_rlce_params_t *p = (dt_iop_rlce_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
dt_gui_add_help_link(self->widget, dt_get_help_url(self->op));
g->vbox1 = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox2), TRUE, TRUE, 0);
g->label1 = dtgtk_reset_label_new(_("radius"), self, &p->radius, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), g->label1, TRUE, TRUE, 0);
g->label2 = dtgtk_reset_label_new(_("amount"), self, &p->slope, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), g->label2, TRUE, TRUE, 0);
g->scale1 = dt_bauhaus_slider_new_with_range(NULL, 0.0, 256.0, 1.0,
p->radius, 0);
g->scale2 = dt_bauhaus_slider_new_with_range(NULL, 1.0, 3.0, 0.05,
p->slope, 2);
// dtgtk_slider_set_format_type(g->scale2,DARKTABLE_SLIDER_FORMAT_PERCENT);
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(GTK_WIDGET(g->scale1), _("size of features to preserve"));
gtk_widget_set_tooltip_text(GTK_WIDGET(g->scale2), _("strength of the effect"));
g_signal_connect(G_OBJECT(g->scale1), "value-changed", G_CALLBACK(radius_callback), self);
g_signal_connect(G_OBJECT(g->scale2), "value-changed", G_CALLBACK(slope_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_global_tonemap_gui_data_t));
dt_iop_global_tonemap_gui_data_t *g = (dt_iop_global_tonemap_gui_data_t *)self->gui_data;
dt_iop_global_tonemap_params_t *p = (dt_iop_global_tonemap_params_t *)self->params;
dt_pthread_mutex_init(&g->lock, NULL);
g->lwmax = NAN;
g->hash = 0;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
dt_gui_add_help_link(self->widget, dt_get_help_url(self->op));
/* operator */
g->operator= dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->operator, NULL, _("operator"));
dt_bauhaus_combobox_add(g->operator, "reinhard");
dt_bauhaus_combobox_add(g->operator, "filmic");
dt_bauhaus_combobox_add(g->operator, "drago");
gtk_widget_set_tooltip_text(g->operator, _("the global tonemap operator"));
g_signal_connect(G_OBJECT(g->operator), "value-changed", G_CALLBACK(operator_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->operator), TRUE, TRUE, 0);
/* drago bias */
g->drago.bias = dt_bauhaus_slider_new_with_range(self, 0.5, 1.0, 0.05, p->drago.bias, 2);
dt_bauhaus_widget_set_label(g->drago.bias, NULL, _("bias"));
gtk_widget_set_tooltip_text(g->drago.bias, _("the bias for tonemapper controls the linearity, "
"the higher the more details in blacks"));
g_signal_connect(G_OBJECT(g->drago.bias), "value-changed", G_CALLBACK(_drago_bias_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->drago.bias, TRUE, TRUE, 0);
/* drago bias */
g->drago.max_light = dt_bauhaus_slider_new_with_range(self, 1, 500, 10, p->drago.max_light, 2);
dt_bauhaus_widget_set_label(g->drago.max_light, NULL, _("target"));
gtk_widget_set_tooltip_text(g->drago.max_light, _("the target light for tonemapper specified as cd/m2"));
g_signal_connect(G_OBJECT(g->drago.max_light), "value-changed", G_CALLBACK(_drago_max_light_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->drago.max_light, TRUE, TRUE, 0);
/* detail */
g->detail = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.01, 0.0, 3);
gtk_box_pack_start(GTK_BOX(self->widget), g->detail, TRUE, TRUE, 0);
dt_bauhaus_widget_set_label(g->detail, NULL, _("detail"));
g_signal_connect(G_OBJECT(g->detail), "value-changed", G_CALLBACK(detail_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_monochrome_gui_data_t));
dt_iop_monochrome_gui_data_t *g = (dt_iop_monochrome_gui_data_t *)self->gui_data;
g->dragging = 0;
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
dt_gui_add_help_link(self->widget, dt_get_help_url(self->op));
g->area = GTK_DRAWING_AREA(dtgtk_drawing_area_new_with_aspect_ratio(1.0));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->area), TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(GTK_WIDGET(g->area), _("drag and scroll mouse wheel to adjust the virtual color filter"));
gtk_widget_add_events(GTK_WIDGET(g->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_LEAVE_NOTIFY_MASK | darktable.gui->scroll_mask);
g_signal_connect(G_OBJECT(g->area), "draw", G_CALLBACK(dt_iop_monochrome_draw), self);
g_signal_connect(G_OBJECT(g->area), "button-press-event", G_CALLBACK(dt_iop_monochrome_button_press), self);
g_signal_connect(G_OBJECT(g->area), "button-release-event", G_CALLBACK(dt_iop_monochrome_button_release),
self);
g_signal_connect(G_OBJECT(g->area), "motion-notify-event", G_CALLBACK(dt_iop_monochrome_motion_notify),
self);
g_signal_connect(G_OBJECT(g->area), "leave-notify-event", G_CALLBACK(dt_iop_monochrome_leave_notify), self);
g_signal_connect(G_OBJECT(g->area), "scroll-event", G_CALLBACK(dt_iop_monochrome_scrolled), self);
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_BAUHAUS_SPACE);
g->highlights = dt_bauhaus_slider_new_with_range(self, 0.0, 1.0, 0.01, 0.0, 2);
gtk_widget_set_tooltip_text(g->highlights, _("how much to keep highlights"));
dt_bauhaus_widget_set_label(g->highlights, NULL, _("highlights"));
gtk_box_pack_start(GTK_BOX(box), g->highlights, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(g->highlights), "value-changed", G_CALLBACK(highlights_callback), self);
g->colorpicker = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpicker), DT_PIXEL_APPLY_DPI(14), DT_PIXEL_APPLY_DPI(14));
gtk_box_pack_end(GTK_BOX(box), GTK_WIDGET(g->colorpicker), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(g->colorpicker), "toggled", G_CALLBACK(picker_callback), self);
gtk_box_pack_end(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0);
cmsHPROFILE hsRGB = dt_colorspaces_get_profile(DT_COLORSPACE_SRGB, "", DT_PROFILE_DIRECTION_IN)->profile;
cmsHPROFILE hLab = dt_colorspaces_get_profile(DT_COLORSPACE_LAB, "", DT_PROFILE_DIRECTION_ANY)->profile;
g->xform = cmsCreateTransform(hLab, TYPE_Lab_DBL, hsRGB, TYPE_RGB_DBL, INTENT_PERCEPTUAL,
0); // cmsFLAGS_NOTPRECALC);
}
void gui_init(dt_iop_module_t *self)
{
self->widget = gtk_label_new("");
gtk_widget_set_halign(self->widget, GTK_ALIGN_START);
dt_gui_add_help_link(self->widget, dt_get_help_url(self->op));
}
void gui_init(dt_lib_module_t *self)
{
self->data = calloc(1, sizeof(dt_lib_live_view_t));
// Setup lib data
dt_lib_live_view_t *lib = self->data;
lib->splitline_x = lib->splitline_y = 0.5;
// Setup gui
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
dt_gui_add_help_link(self->widget, "live_view.html#live_view");
GtkWidget *box;
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
lib->live_view = dtgtk_togglebutton_new(dtgtk_cairo_paint_eye, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
lib->live_view_zoom = dtgtk_button_new(
dtgtk_cairo_paint_zoom, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL); // TODO: see _zoom_live_view_clicked
lib->rotate_ccw = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
lib->rotate_cw = dtgtk_button_new(dtgtk_cairo_paint_refresh,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_UP, NULL);
lib->flip = dtgtk_togglebutton_new(dtgtk_cairo_paint_flip,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_UP, NULL);
gtk_box_pack_start(GTK_BOX(box), lib->live_view, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->live_view_zoom, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->rotate_ccw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->rotate_cw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->flip, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(lib->live_view, _("toggle live view"));
gtk_widget_set_tooltip_text(lib->live_view_zoom, _("zoom live view"));
gtk_widget_set_tooltip_text(lib->rotate_ccw, _("rotate 90 degrees ccw"));
gtk_widget_set_tooltip_text(lib->rotate_cw, _("rotate 90 degrees cw"));
gtk_widget_set_tooltip_text(lib->flip, _("flip live view horizontally"));
g_signal_connect(G_OBJECT(lib->live_view), "clicked", G_CALLBACK(_toggle_live_view_clicked), lib);
g_signal_connect(G_OBJECT(lib->live_view_zoom), "clicked", G_CALLBACK(_zoom_live_view_clicked), lib);
g_signal_connect(G_OBJECT(lib->rotate_ccw), "clicked", G_CALLBACK(_rotate_ccw), lib);
g_signal_connect(G_OBJECT(lib->rotate_cw), "clicked", G_CALLBACK(_rotate_cw), lib);
g_signal_connect(G_OBJECT(lib->flip), "clicked", G_CALLBACK(_toggle_flip_clicked), lib);
// focus buttons
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
lib->focus_in_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_LEFT, NULL);
lib->focus_in_small
= dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER
| CPF_DIRECTION_LEFT, NULL); // TODO icon not centered
lib->focus_out_small = dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER
| CPF_DIRECTION_RIGHT, NULL); // TODO same here
lib->focus_out_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_RIGHT, NULL);
gtk_box_pack_start(GTK_BOX(box), lib->focus_in_big, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_in_small, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_out_small, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_out_big, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(lib->focus_in_big, _("move focus point in (big steps)"));
gtk_widget_set_tooltip_text(lib->focus_in_small, _("move focus point in (small steps)"));
gtk_widget_set_tooltip_text(lib->focus_out_small, _("move focus point out (small steps)"));
gtk_widget_set_tooltip_text(lib->focus_out_big, _("move focus point out (big steps)"));
// Near 3
g_signal_connect(G_OBJECT(lib->focus_in_big), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(2));
// Near 1
g_signal_connect(G_OBJECT(lib->focus_in_small), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(0));
// Far 1
g_signal_connect(G_OBJECT(lib->focus_out_small), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(4));
// Far 3
g_signal_connect(G_OBJECT(lib->focus_out_big), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(6));
// Guides
lib->guide_selector = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->guide_selector, NULL, _("guides"));
gtk_box_pack_start(GTK_BOX(self->widget), lib->guide_selector, TRUE, TRUE, 0);
lib->guides_widgets = gtk_stack_new();
gtk_stack_set_homogeneous(GTK_STACK(lib->guides_widgets), FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), lib->guides_widgets, TRUE, TRUE, 0);
dt_bauhaus_combobox_add(lib->guide_selector, _("none"));
int i = 0;
for(GList *iter = darktable.guides; iter; iter = g_list_next(iter), i++)
{
GtkWidget *widget = NULL;
dt_guides_t *guide = (dt_guides_t *)iter->data;
dt_bauhaus_combobox_add(lib->guide_selector, _(guide->name));
if(guide->widget)
{
// generate some unique name so that we can have the same name several times
char name[5];
snprintf(name, sizeof(name), "%d", i);
widget = guide->widget(NULL, guide->user_data);
gtk_widget_show_all(widget);
gtk_stack_add_named(GTK_STACK(lib->guides_widgets), widget, name);
}
lib->guides_widgets_list = g_list_append(lib->guides_widgets_list, widget);
}
gtk_widget_set_no_show_all(lib->guides_widgets, TRUE);
gtk_widget_set_tooltip_text(lib->guide_selector, _("display guide lines to help compose your photograph"));
g_signal_connect(G_OBJECT(lib->guide_selector), "value-changed", G_CALLBACK(guides_presets_changed), lib);
lib->flip_guides = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->flip_guides, NULL, _("flip"));
dt_bauhaus_combobox_add(lib->flip_guides, _("none"));
dt_bauhaus_combobox_add(lib->flip_guides, _("horizontally"));
dt_bauhaus_combobox_add(lib->flip_guides, _("vertically"));
dt_bauhaus_combobox_add(lib->flip_guides, _("both"));
gtk_widget_set_tooltip_text(lib->flip_guides, _("flip guides"));
gtk_box_pack_start(GTK_BOX(self->widget), lib->flip_guides, TRUE, TRUE, 0);
lib->overlay = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay, NULL, _("overlay"));
dt_bauhaus_combobox_add(lib->overlay, _("none"));
dt_bauhaus_combobox_add(lib->overlay, _("selected image"));
dt_bauhaus_combobox_add(lib->overlay, _("id"));
gtk_widget_set_tooltip_text(lib->overlay, _("overlay another image over the live view"));
g_signal_connect(G_OBJECT(lib->overlay), "value-changed", G_CALLBACK(overlay_changed), lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay, TRUE, TRUE, 0);
lib->overlay_id_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *label = gtk_label_new(_("image id"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
lib->overlay_id = gtk_spin_button_new_with_range(0, 1000000000, 1);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(lib->overlay_id), 0);
gtk_widget_set_tooltip_text(lib->overlay_id, _("enter image id of the overlay manually"));
g_signal_connect(G_OBJECT(lib->overlay_id), "value-changed", G_CALLBACK(_overlay_id_changed), lib);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lib->overlay_id),
dt_conf_get_int("plugins/lighttable/live_view/overlay_imgid"));
gtk_box_pack_start(GTK_BOX(lib->overlay_id_box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(lib->overlay_id_box), lib->overlay_id, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_id_box, TRUE, TRUE, 0);
gtk_widget_show(lib->overlay_id);
gtk_widget_show(label);
lib->overlay_mode = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay_mode, NULL, _("overlay mode"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "normal"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "xor"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "add"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "saturate"));
#if(CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 10, 0))
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "multiply"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "screen"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "overlay"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "darken"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "lighten"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "color dodge"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "color burn"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "hard light"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "soft light"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "difference"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "exclusion"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL hue"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL saturation"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL color"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL luminosity"));
#endif
gtk_widget_set_tooltip_text(lib->overlay_mode, _("mode of the overlay"));
dt_bauhaus_combobox_set(lib->overlay_mode, dt_conf_get_int("plugins/lighttable/live_view/overlay_mode"));
g_signal_connect(G_OBJECT(lib->overlay_mode), "value-changed", G_CALLBACK(_overlay_mode_changed), lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_mode, TRUE, TRUE, 0);
lib->overlay_splitline = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay_splitline, NULL, _("split line"));
dt_bauhaus_combobox_add(lib->overlay_splitline, _("off"));
dt_bauhaus_combobox_add(lib->overlay_splitline, _("on"));
gtk_widget_set_tooltip_text(lib->overlay_splitline, _("only draw part of the overlay"));
dt_bauhaus_combobox_set(lib->overlay_splitline, dt_conf_get_int("plugins/lighttable/live_view/splitline"));
g_signal_connect(G_OBJECT(lib->overlay_splitline), "value-changed", G_CALLBACK(_overlay_splitline_changed),
lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_splitline, TRUE, TRUE, 0);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_mode), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_id_box), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_splitline), FALSE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_mode), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_id_box), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_splitline), TRUE);
guides_presets_set_visibility(lib, 0);
}
void gui_init(dt_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;
c->hash = 0;
dt_pthread_mutex_unlock(&c->lock);
c->modes = NULL;
c->mouse_x = c->mouse_y = -1.0;
c->dragging = 0;
c->activeToggleButton = NULL;
c->last_picked_color = -1;
self->widget = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
dt_gui_add_help_link(self->widget, dt_get_help_url(self->op));
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 | darktable.gui->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));
c->blackpick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT, NULL);
gtk_widget_set_tooltip_text(c->blackpick, _("pick black point from image"));
c->greypick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT, NULL);
gtk_widget_set_tooltip_text(c->greypick, _("pick medium gray point from image"));
c->whitepick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT, NULL);
gtk_widget_set_tooltip_text(c->whitepick, _("pick white point from image"));
GdkRGBA color = { 0 };
color.alpha = 1.0;
dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(c->blackpick), &color);
color.red = color.green = color.blue = 0.5;
dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(c->greypick), &color);
color.red = color.green = color.blue = 1.0;
dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(c->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(c->blackpick), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(c->greypick), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(box), GTK_WIDGET(c->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(c->blackpick), "toggled", G_CALLBACK(dt_iop_color_picker_callback), &c->color_picker);
g_signal_connect(G_OBJECT(c->greypick), "toggled", G_CALLBACK(dt_iop_color_picker_callback), &c->color_picker);
g_signal_connect(G_OBJECT(c->whitepick), "toggled", G_CALLBACK(dt_iop_color_picker_callback), &c->color_picker);
dt_iop_init_picker(&c->color_picker, self, DT_COLOR_PICKER_POINT, _iop_color_picker_get_set,
_iop_color_picker_apply, _iop_color_picker_update);
}
void gui_init(dt_lib_module_t *self)
{
dt_lib_image_t *d = (dt_lib_image_t *)malloc(sizeof(dt_lib_image_t));
self->data = (void *)d;
self->widget = gtk_grid_new();
dt_gui_add_help_link(self->widget, "selected_images.html#selected_images_usage");
GtkGrid *grid = GTK_GRID(self->widget);
gtk_grid_set_row_spacing(grid, DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_spacing(grid, DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_homogeneous(grid, TRUE);
int line = 0;
GtkWidget *button;
button = gtk_button_new_with_label(_("remove"));
ellipsize_button(button);
d->remove_button = button;
gtk_widget_set_tooltip_text(button, _("remove from the collection"));
gtk_grid_attach(grid, button, 0, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(0));
button = gtk_button_new_with_label(_image_get_delete_button_label());
ellipsize_button(button);
d->delete_button = button;
gtk_widget_set_tooltip_text(button, _image_get_delete_button_tooltip());
gtk_grid_attach(grid, button, 2, line++, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(1));
button = gtk_button_new_with_label(_("move"));
ellipsize_button(button);
d->move_button = button;
gtk_widget_set_tooltip_text(button, _("move to other folder"));
gtk_grid_attach(grid, button, 0, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(8));
button = gtk_button_new_with_label(_("copy"));
ellipsize_button(button);
d->copy_button = button;
gtk_widget_set_tooltip_text(button, _("copy to other folder"));
gtk_grid_attach(grid, button, 2, line++, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(9));
button = gtk_button_new_with_label(_("create HDR"));
ellipsize_button(button);
d->create_hdr_button = button;
gtk_grid_attach(grid, button, 0, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(7));
gtk_widget_set_tooltip_text(button, _("create a high dynamic range image from selected shots"));
button = gtk_button_new_with_label(_("duplicate"));
ellipsize_button(button);
d->duplicate_button = button;
gtk_widget_set_tooltip_text(button, _("add a duplicate to the collection, including its history stack"));
gtk_grid_attach(grid, button, 2, line++, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(3));
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_DO_NOT_USE_BORDER, NULL);
d->rotate_ccw_button = button;
gtk_widget_set_tooltip_text(button, _("rotate selected images 90 degrees CCW"));
gtk_grid_attach(grid, button, 0, line, 1, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(4));
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, 1 | CPF_DO_NOT_USE_BORDER, NULL);
d->rotate_cw_button = button;
gtk_widget_set_tooltip_text(button, _("rotate selected images 90 degrees CW"));
gtk_grid_attach(grid, button, 1, line, 1, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(5));
button = gtk_button_new_with_label(_("reset rotation"));
ellipsize_button(button);
d->reset_button = button;
gtk_widget_set_tooltip_text(button, _("reset rotation to EXIF data"));
gtk_grid_attach(grid, button, 2, line++, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(6));
button = gtk_button_new_with_label(_("copy locally"));
ellipsize_button(button);
d->cache_button = button;
gtk_widget_set_tooltip_text(button, _("copy the image locally"));
gtk_grid_attach(grid, button, 0, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(12));
button = gtk_button_new_with_label(_("resync local copy"));
ellipsize_button(button);
d->uncache_button = button;
gtk_widget_set_tooltip_text(button, _("synchronize the image's XMP and remove the local copy"));
gtk_grid_attach(grid, button, 2, line++, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(13));
button = gtk_button_new_with_label(_("group"));
ellipsize_button(button);
d->group_button = button;
gtk_widget_set_tooltip_text(button, _("add selected images to expanded group or create a new one"));
gtk_grid_attach(grid, button, 0, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(10));
button = gtk_button_new_with_label(_("ungroup"));
ellipsize_button(button);
d->ungroup_button = button;
gtk_widget_set_tooltip_text(button, _("remove selected images from the group"));
gtk_grid_attach(grid, button, 2, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(11));
/* connect preference changed signal */
dt_control_signal_connect(
darktable.signals,
DT_SIGNAL_PREFERENCES_CHANGE,
G_CALLBACK(_image_preference_changed),
(gpointer)self);
}
