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