void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_channelmixer_gui_data_t));
dt_iop_channelmixer_gui_data_t *g = (dt_iop_channelmixer_gui_data_t *)self->gui_data;
dt_iop_channelmixer_params_t *p = (dt_iop_channelmixer_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->dtlabel1 = DTGTK_LABEL( dtgtk_label_new(_("output channel"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT) );
g->combo1 = GTK_COMBO_BOX( gtk_combo_box_new_text() );
gtk_combo_box_append_text(g->combo1,_("hue"));
gtk_combo_box_append_text(g->combo1,_("saturation"));
gtk_combo_box_append_text(g->combo1,_("lightness"));
gtk_combo_box_append_text(g->combo1,_("red"));
gtk_combo_box_append_text(g->combo1,_("green"));
gtk_combo_box_append_text(g->combo1,_("blue"));
gtk_combo_box_append_text(g->combo1,_("gray"));
gtk_combo_box_set_active(g->combo1, CHANNEL_RED );
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->dtlabel1), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->combo1), TRUE, TRUE, 5);
g->dtlabel2 = DTGTK_LABEL( dtgtk_label_new(_("source channels"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT) );
GtkBox *hbox = GTK_BOX( gtk_hbox_new(FALSE, 0));
g->vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->dtlabel2), TRUE, TRUE, 5);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,-2.0, 2.0, 0.005, p->red[CHANNEL_RED] , 3));
g_object_set (GTK_OBJECT(g->scale1), "tooltip-text", _("amount of red channel in the output channel"), (char *)NULL);
dtgtk_slider_set_label(g->scale1,_("red"));
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,-2.0, 2.0, 0.005, p->green[CHANNEL_RED] , 3));
g_object_set (GTK_OBJECT(g->scale2), "tooltip-text", _("amount of green channel in the output channel"), (char *)NULL);
dtgtk_slider_set_label(g->scale2,_("green"));
g->scale3 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,-2.0, 2.0, 0.005, p->blue[CHANNEL_RED] , 3));
g_object_set (GTK_OBJECT(g->scale3), "tooltip-text", _("amount of blue channel in the output channel"), (char *)NULL);
dtgtk_slider_set_label(g->scale3,_("blue"));
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale3), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (red_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (green_callback), self);
g_signal_connect (G_OBJECT (g->scale3), "value-changed",
G_CALLBACK (blue_callback), self);
g_signal_connect (G_OBJECT (g->combo1), "changed",
G_CALLBACK (output_callback), self);
}
static inline void
gui_init_tab(
struct dt_iop_module_t *self,
const char* name,
GtkDarktableButton** ppcolor,
GtkWidget** pphue,
GtkWidget** ppsaturation)
{
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(dtgtk_label_new(name,DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT)), FALSE, FALSE, 5);
// color button
GtkDarktableButton* color;
*ppcolor = color = 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(color),32,32);
// hue slider
GtkWidget* hue;
*pphue = hue =( dt_bauhaus_slider_new_with_range_and_feedback(self, 0.0f, 1.0f, 0.01f, 0.0f, 2, 0));
dt_bauhaus_slider_set_stop(hue, 0.0f, 1.0f, 0.0f, 0.0f);
dt_bauhaus_widget_set_label(hue, NULL, _("hue"));
dt_bauhaus_slider_set_stop(hue, 0.166f, 1.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(hue, 0.322f, 0.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(hue, 0.498f, 0.0f, 1.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 0.664f, 0.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 0.830f, 1.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 1.0f, 1.0f, 0.0f, 0.0f);
g_object_set(G_OBJECT(hue), "tooltip-text", _("select the hue tone"), (char *)NULL);
// saturation slider
GtkWidget* saturation;
*ppsaturation = saturation = dt_bauhaus_slider_new_with_range(self, 0.0f, 1.0f, 0.01f, 0.0f, 2);
dt_bauhaus_widget_set_label(saturation, NULL, _("saturation"));
dt_bauhaus_slider_set_stop(saturation, 0.0f, 0.2f, 0.2f, 0.2f);
dt_bauhaus_slider_set_stop(saturation, 1.0f, 1.0f, 1.0f, 1.0f);
g_object_set(G_OBJECT(saturation), "tooltip-text", _("select the saturation tone"), (char *)NULL);
// pack the widgets
GtkWidget* vbox = gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hue), FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), GTK_WIDGET(saturation), FALSE, TRUE, 0);
GtkWidget* hbox = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), GTK_WIDGET(color),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
}
void
gui_init (dt_lib_module_t *self)
{
dt_lib_export_t *d = (dt_lib_export_t *)malloc(sizeof(dt_lib_export_t));
self->data = (void *)d;
self->widget = gtk_table_new(8, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(self->widget), 5);
GtkWidget *label;
label = dtgtk_label_new(_("target storage"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 2, 0, 1, GTK_FILL|GTK_EXPAND, 0, 0, 0);
d->storage = GTK_COMBO_BOX(gtk_combo_box_new_text());
GList *it = darktable.imageio->plugins_storage;
while(it)
{
dt_imageio_module_storage_t *module = (dt_imageio_module_storage_t *)it->data;
gtk_combo_box_append_text(d->storage, module->name(module));
it = g_list_next(it);
}
dt_control_signal_connect(darktable.signals,DT_SIGNAL_IMAGEIO_STORAGE_CHANGE,G_CALLBACK(on_storage_list_changed),self);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->storage), 0, 2, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0);
g_signal_connect (G_OBJECT (d->storage), "changed",
G_CALLBACK (storage_changed),
(gpointer)d);
d->storage_box = GTK_CONTAINER(gtk_alignment_new(1.0, 1.0, 1.0, 1.0));
gtk_alignment_set_padding(GTK_ALIGNMENT(d->storage_box), 0, 0, 0, 0);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->storage_box), 0, 2, 2, 3, GTK_EXPAND|GTK_FILL, 0, 0, 0);
label = dtgtk_label_new(_("file format"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_set_row_spacing(GTK_TABLE(self->widget), 2, 20);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 2, 3, 4, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->format = GTK_COMBO_BOX(gtk_combo_box_new_text());
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->format), 0, 2, 4, 5, GTK_EXPAND|GTK_FILL, 0, 0, 0);
g_signal_connect (G_OBJECT (d->format), "changed",
G_CALLBACK (format_changed),
(gpointer)d);
d->format_box = GTK_CONTAINER(gtk_alignment_new(1.0, 1.0, 1.0, 1.0));
gtk_alignment_set_padding(GTK_ALIGNMENT(d->format_box), 0, 0, 0, 0);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->format_box), 0, 2, 5, 6, GTK_EXPAND|GTK_FILL, 0, 0, 0);
label = dtgtk_label_new(_("global options"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT);
gtk_table_set_row_spacing(GTK_TABLE(self->widget), 5, 20);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 2, 6, 7, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->width = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 10000, 1));
g_object_set(G_OBJECT(d->width), "tooltip-text", _("maximum output width\nset to 0 for no scaling"), (char *)NULL);
d->height = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 10000, 1));
g_object_set(G_OBJECT(d->height), "tooltip-text", _("maximum output height\nset to 0 for no scaling"), (char *)NULL);
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (d->width));
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (d->height));
/*
gtk_widget_add_events(GTK_WIDGET(d->width), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (d->width), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (d->width), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(d->height), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (d->height), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (d->height), "focus-out-event", G_CALLBACK(focus_out), NULL);
*/
label = gtk_label_new(_("max size"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 7, 8, GTK_EXPAND|GTK_FILL, 0, 0, 0);
GtkBox *hbox = GTK_BOX(gtk_hbox_new(FALSE, 5));
gtk_box_pack_start(hbox, GTK_WIDGET(d->width), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, gtk_label_new(_("x")), FALSE, FALSE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(d->height), TRUE, TRUE, 0);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(hbox), 1, 2, 7, 8, GTK_EXPAND|GTK_FILL, 0, 0, 0);
label = gtk_label_new(_("intent"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 8, 9, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->intent = GTK_COMBO_BOX(gtk_combo_box_new_text());
gtk_combo_box_append_text(d->intent, _("image settings"));
gtk_combo_box_append_text(d->intent, _("perceptual"));
gtk_combo_box_append_text(d->intent, _("relative colorimetric"));
gtk_combo_box_append_text(d->intent, C_("rendering intent", "saturation"));
gtk_combo_box_append_text(d->intent, _("absolute colorimetric"));
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->intent), 1, 2, 8, 9, GTK_EXPAND|GTK_FILL, 0, 0, 0);
// Add profile combo
d->profiles = NULL;
dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));
g_strlcpy(prof->filename, "sRGB", sizeof(prof->filename));
g_strlcpy(prof->name, _("sRGB (web-safe)"), sizeof(prof->name));
int pos;
prof->pos = 1;
d->profiles = g_list_append(d->profiles, prof);
prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));
g_strlcpy(prof->filename, "adobergb", sizeof(prof->filename));
g_strlcpy(prof->name, _("Adobe RGB"), sizeof(prof->name));
prof->pos = 2;
d->profiles = g_list_append(d->profiles, prof);
prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));
g_strlcpy(prof->filename, "X profile", sizeof(prof->filename));
g_strlcpy(prof->name, "X profile", sizeof(prof->name));
prof->pos = 3;
d->profiles = g_list_append(d->profiles, prof);
prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));
g_strlcpy(prof->filename, "linear_rgb", sizeof(prof->filename));
g_strlcpy(prof->name, _("linear RGB"), sizeof(prof->name));
pos = prof->pos = 4;
d->profiles = g_list_append(d->profiles, prof);
// read datadir/color/out/*.icc
char datadir[DT_MAX_PATH_LEN];
char confdir[DT_MAX_PATH_LEN];
char dirname[DT_MAX_PATH_LEN];
char filename[DT_MAX_PATH_LEN];
dt_loc_get_user_config_dir(confdir, DT_MAX_PATH_LEN);
dt_loc_get_datadir(datadir, DT_MAX_PATH_LEN);
cmsHPROFILE tmpprof;
const gchar *d_name;
snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", confdir);
if(!g_file_test(dirname, G_FILE_TEST_IS_DIR))
snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", datadir);
GDir *dir = g_dir_open(dirname, 0, NULL);
if(dir)
{
while((d_name = g_dir_read_name(dir)))
{
snprintf(filename, DT_MAX_PATH_LEN, "%s/%s", dirname, d_name);
tmpprof = cmsOpenProfileFromFile(filename, "r");
if(tmpprof)
{
char *lang = getenv("LANG");
if (!lang) lang = "en_US";
dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));
char name[1024];
cmsGetProfileInfoASCII(tmpprof, cmsInfoDescription, lang, lang+3, name, 1024);
g_strlcpy(prof->name, name, sizeof(prof->name));
g_strlcpy(prof->filename, d_name, sizeof(prof->filename));
prof->pos = ++pos;
cmsCloseProfile(tmpprof);
d->profiles = g_list_append(d->profiles, prof);
}
}
g_dir_close(dir);
}
GList *l = d->profiles;
label = gtk_label_new(_("profile"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 9, 10, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->profile = GTK_COMBO_BOX(gtk_combo_box_new_text());
dt_ellipsize_combo(d->profile);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->profile), 1, 2, 9, 10, GTK_SHRINK|GTK_EXPAND|GTK_FILL, 0, 0, 0);
// gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->profile), 1, 2, 9, 10, GTK_EXPAND|GTK_FILL, 0, 0, 0);
gtk_combo_box_append_text(d->profile, _("image settings"));
while(l)
{
dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)l->data;
if(!strcmp(prof->name, "X profile"))
gtk_combo_box_append_text(d->profile, _("system display profile"));
else
gtk_combo_box_append_text(d->profile, prof->name);
l = g_list_next(l);
}
gtk_combo_box_set_active(d->profile, 0);
char tooltip[1024];
snprintf(tooltip, 1024, _("output icc profiles in %s/color/out or %s/color/out"), confdir, datadir);
g_object_set(G_OBJECT(d->profile), "tooltip-text", tooltip, (char *)NULL);
// Add style combo
label = gtk_label_new(_("style"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 10, 11, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->style = GTK_COMBO_BOX(gtk_combo_box_new_text());
dt_ellipsize_combo(d->style);
gtk_combo_box_append_text(d->style, _("none"));
GList *styles = dt_styles_get_list("");
while (styles)
{
dt_style_t *style=(dt_style_t *)styles->data;
gtk_combo_box_append_text(d->style, style->name);
styles=g_list_next(styles);
}
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->style), 1, 2, 10, 11, GTK_EXPAND|GTK_FILL, 0, 0, 0);
g_object_set(G_OBJECT(d->style), "tooltip-text", _("temporary style to append while exporting"), (char *)NULL);
// Set callback signals
g_signal_connect (G_OBJECT (d->intent), "changed",
G_CALLBACK (intent_changed),
(gpointer)d);
g_signal_connect (G_OBJECT (d->profile), "changed",
G_CALLBACK (profile_changed),
(gpointer)d);
g_signal_connect (G_OBJECT (d->style), "changed",
G_CALLBACK (style_changed),
(gpointer)d);
// Export button
GtkButton *button = GTK_BUTTON(gtk_button_new_with_label(_("export")));
d->export_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("export with current settings (ctrl-e)"), (char *)NULL);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(button), 1, 2, 11, 12, GTK_EXPAND|GTK_FILL, 0, 0, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (export_button_clicked),
(gpointer)self);
g_signal_connect (G_OBJECT (d->width), "value-changed",
G_CALLBACK (width_changed),
(gpointer)0);
g_signal_connect (G_OBJECT (d->height), "value-changed",
G_CALLBACK (height_changed),
(gpointer)0);
self->gui_reset(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)
{
unsigned int i;
GtkWidget *container = gtk_vbox_new(FALSE, 5);
GtkWidget *output_row = gtk_hbox_new(FALSE, 2);
GtkWidget *output_options = gtk_vbox_new(FALSE, 5);
GtkWidget *picker_subrow = gtk_hbox_new(FALSE, 2);
GtkWidget *restrict_button;
GtkWidget *samples_label = dtgtk_label_new(_("live samples"),
DARKTABLE_LABEL_TAB
| DARKTABLE_LABEL_ALIGN_RIGHT);
GtkWidget *samples_options_row = gtk_hbox_new(FALSE, 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;
// 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 output button
data->output_button = dtgtk_button_new(NULL, CPF_STYLE_BOX);
gtk_widget_set_size_request(data->output_button, DT_PIXEL_APPLY_DPI(100), DT_PIXEL_APPLY_DPI(100));
gtk_widget_set_sensitive(data->output_button, FALSE);
gtk_box_pack_start(GTK_BOX(output_row), data->output_button, 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_vbox_new(FALSE, 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 (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 _camera_import_dialog_new(_camera_import_dialog_t *data)
{
data->dialog=gtk_dialog_new_with_buttons(_("import images from camera"),NULL,GTK_DIALOG_MODAL,_("cancel"),GTK_RESPONSE_NONE,C_("camera import", "import"),GTK_RESPONSE_ACCEPT,NULL);
GtkWidget *content = gtk_dialog_get_content_area (GTK_DIALOG (data->dialog));
// List - setup store
data->store = gtk_list_store_new (2,GDK_TYPE_PIXBUF,G_TYPE_STRING);
// IMPORT PAGE
data->import.page=gtk_vbox_new(FALSE,5);
gtk_container_set_border_width(GTK_CONTAINER(data->import.page),5);
// Top info
data->import.info=gtk_label_new( _("please wait while prefetching thumbnails of images from camera...") );
gtk_label_set_single_line_mode( GTK_LABEL(data->import.info) , FALSE );
gtk_misc_set_alignment(GTK_MISC(data->import.info), 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(data->import.page),data->import.info,FALSE,FALSE,0);
// jobcode
data->import.jobname=_camera_import_gconf_widget(data,_("jobcode"),"plugins/capture/camera/import/jobcode");
gtk_box_pack_start(GTK_BOX(data->import.page),GTK_WIDGET(data->import.jobname->widget),FALSE,FALSE,0);
// Create the treview with list model data store
data->import.treeview=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->import.treeview),GTK_POLICY_NEVER,GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(data->import.treeview), gtk_tree_view_new());
GtkTreeView *treeview=GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview)));
GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new( );
GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes( _("thumbnail") , renderer,"pixbuf",0, (char *)NULL);
gtk_tree_view_append_column( treeview , column);
renderer = gtk_cell_renderer_text_new( );
column = gtk_tree_view_column_new_with_attributes( _("storage file"), renderer, "text", 1, (char *)NULL);
gtk_tree_view_append_column( treeview , column);
gtk_tree_view_column_set_expand( column, TRUE);
GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection,GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_model(treeview,GTK_TREE_MODEL(data->store));
gtk_tree_view_set_headers_visible(treeview,FALSE);
gtk_box_pack_start(GTK_BOX(data->import.page),data->import.treeview,TRUE,TRUE,0);
// SETTINGS PAGE
data->settings.page=gtk_vbox_new(FALSE,5);
gtk_container_set_border_width(GTK_CONTAINER(data->settings.page),5);
// general settings
gtk_box_pack_start(GTK_BOX(data->settings.page),dtgtk_label_new(_("general"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT),FALSE,FALSE,0);
// ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.
data->settings.general.ignore_jpeg = gtk_check_button_new_with_label (_("ignore JPEG files"));
g_object_set(data->settings.general.ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are raw+JPEG in a directory."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->settings.general.ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs"));
gtk_box_pack_start(GTK_BOX(data->settings.page), data->settings.general.ignore_jpeg, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT(data->settings.general.ignore_jpeg), "clicked",G_CALLBACK (_check_button_callback),data);
GtkWidget *hbox=gtk_hbox_new(FALSE,5);
data->settings.general.date_override=gtk_check_button_new_with_label(_("override today's date"));
gtk_box_pack_start(GTK_BOX(hbox),data->settings.general.date_override,FALSE,FALSE,0);
g_object_set(data->settings.general.date_override,"tooltip-text",_("check this, if you want to override the timestamp used when expanding variables:\n$(YEAR), $(MONTH), $(DAY),\n$(HOUR), $(MINUTE), $(SECONDS)"),(char *)NULL);
data->settings.general.date_entry=gtk_entry_new();
gtk_widget_set_sensitive( data->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override)));
gtk_box_pack_start(GTK_BOX(hbox),data->settings.general.date_entry,TRUE,TRUE,0);
g_signal_connect (G_OBJECT (data->settings.general.date_override), "clicked",G_CALLBACK (_check_button_callback),data);
gtk_box_pack_start(GTK_BOX(data->settings.page),hbox,FALSE,FALSE,0);
// THE NOTEBOOK
data->notebook=gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook),data->import.page,gtk_label_new(_("images")));
gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook),data->settings.page,gtk_label_new(_("settings")));
// end
gtk_box_pack_start(GTK_BOX(content),data->notebook,TRUE,TRUE,0);
//gtk_widget_set_size_request(content,400,400);
}
/** update the device list */
void _lib_import_ui_devices_update(dt_lib_module_t *self)
{
dt_lib_import_t *d = (dt_lib_import_t*)self->data;
GList *citem;
/* cleanup of widgets in devices container*/
GList *item;
if((item=gtk_container_get_children(GTK_CONTAINER(d->devices)))!=NULL)
do
{
gtk_container_remove(GTK_CONTAINER(d->devices),GTK_WIDGET(item->data));
}
while((item=g_list_next(item))!=NULL);
/* add the rescan button */
GtkButton *scan = GTK_BUTTON(gtk_button_new_with_label(_("scan for devices")));
d->scan_devices = scan;
gtk_button_set_alignment(scan, 0.05, 0.5);
g_object_set(G_OBJECT(scan), "tooltip-text", _("scan for newly attached devices"), (char *)NULL);
g_signal_connect (G_OBJECT(scan), "clicked",G_CALLBACK (_lib_import_scan_devices_callback), self);
gtk_box_pack_start(GTK_BOX(d->devices),GTK_WIDGET(scan),TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(d->devices),GTK_WIDGET(gtk_label_new("")),TRUE,TRUE,0);
uint32_t count=0;
/* FIXME: Verify that it's safe to access camctl->cameras list here ? */
if( (citem = g_list_first (darktable.camctl->cameras))!=NULL)
{
// Add detected supported devices
char buffer[512]= {0};
do
{
dt_camera_t *camera=(dt_camera_t *)citem->data;
count++;
/* add camera label */
GtkWidget *label = GTK_WIDGET (dtgtk_label_new (camera->model,DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_LEFT));
gtk_box_pack_start (GTK_BOX (d->devices),label,TRUE,TRUE,0);
/* set camera summary if available */
if( camera->summary.text !=NULL && strlen(camera->summary.text) >0 )
{
g_object_set(G_OBJECT(label), "tooltip-text", camera->summary.text, (char *)NULL);
}
else
{
sprintf(buffer,_("device \"%s\" connected on port \"%s\"."),camera->model,camera->port);
g_object_set(G_OBJECT(label), "tooltip-text", buffer, (char *)NULL);
}
/* add camera actions buttons */
GtkWidget *ib=NULL,*tb=NULL;
GtkWidget *vbx=gtk_vbox_new(FALSE,5);
if( camera->can_import==TRUE )
{
gtk_box_pack_start (GTK_BOX (vbx),(ib=gtk_button_new_with_label (_("import from camera"))),FALSE,FALSE,0);
d->import_camera = GTK_BUTTON(ib);
}
if( camera->can_tether==TRUE )
{
gtk_box_pack_start (GTK_BOX (vbx),(tb=gtk_button_new_with_label (_("tethered shoot"))),FALSE,FALSE,0);
d->tethered_shoot = GTK_BUTTON(tb);
}
if( ib )
{
g_signal_connect (G_OBJECT (ib), "clicked",G_CALLBACK (_lib_import_from_camera_callback), camera);
gtk_button_set_alignment(GTK_BUTTON(ib), 0.05, 0.5);
}
if( tb )
{
g_signal_connect (G_OBJECT (tb), "clicked",G_CALLBACK (_lib_import_tethered_callback), camera);
gtk_button_set_alignment(GTK_BUTTON(tb), 0.05, 0.5);
}
gtk_box_pack_start (GTK_BOX (d->devices),vbx,FALSE,FALSE,0);
}
while ((citem=g_list_next (citem))!=NULL);
}
if( count == 0 )
{
// No supported devices is detected lets notice user..
gtk_box_pack_start(GTK_BOX(d->devices),gtk_label_new(_("no supported devices found")),TRUE,TRUE,0);
}
gtk_widget_show_all(GTK_WIDGET(d->devices));
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_splittoning_gui_data_t));
dt_iop_splittoning_gui_data_t *g = (dt_iop_splittoning_gui_data_t *)self->gui_data;
dt_iop_splittoning_params_t *p = (dt_iop_splittoning_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, 0));
// Shadows
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(dtgtk_label_new(_("shadows"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT)), FALSE, FALSE, 5);
g->colorpick1 = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color,CPF_IGNORE_FG_STATE|CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick1),32,32);
GtkWidget *hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox1 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_end(GTK_BOX(hbox),GTK_WIDGET(g->colorpick1),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->label1 = dtgtk_reset_label_new (_("hue"), self, &p->shadow_hue, sizeof(float));
g->label2 = dtgtk_reset_label_new (_("saturation"), self, &p->shadow_saturation, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label2), TRUE, TRUE, 0);
int lightness=32768;
g->gslider1=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,0,0
},(GdkColor)
{
0,lightness,0,0
}));
dtgtk_gradient_slider_set_stop(g->gslider1,0.166,(GdkColor)
{
0,lightness,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.332,(GdkColor)
{
0,0,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.498,(GdkColor)
{
0,0,lightness,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.664,(GdkColor)
{
0,0,0,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.83,(GdkColor)
{
0,lightness,0,lightness
});
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider1), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider1), "tooltip-text", _("select the hue tone for shadows"), (char *)NULL);
g->gslider2=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,lightness,lightness
},(GdkColor)
{
0,lightness,lightness,lightness
}));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider2), "tooltip-text", _("select the saturation shadow tone"), (char *)NULL);
// Highlights
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(dtgtk_label_new(_("highlights"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT)), FALSE, FALSE, 5);
g->colorpick2 = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color,CPF_IGNORE_FG_STATE|CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick2),32,32);
hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox1 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_end(GTK_BOX(hbox),GTK_WIDGET(g->colorpick2),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->label3 = dtgtk_reset_label_new (_("hue"), self, &p->highlight_hue, sizeof(float));
g->label4 = dtgtk_reset_label_new (_("saturation"), self, &p->highlight_saturation, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label3), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label4), TRUE, TRUE, 0);
g->gslider3=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,0,0
},(GdkColor)
{
0,lightness,0,0
}));
dtgtk_gradient_slider_set_stop(g->gslider3,0.166,(GdkColor)
{
0,lightness,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.332,(GdkColor)
{
0,0,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.498,(GdkColor)
{
0,0,lightness,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.664,(GdkColor)
{
0,0,0,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.83,(GdkColor)
{
0,lightness,0,lightness
});
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider3), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider3), "tooltip-text", _("select the hue tone for highlights"), (char *)NULL);
g->gslider4=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,lightness,lightness
},(GdkColor)
{
0,lightness,lightness,lightness
}));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider4), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider4), "tooltip-text", _("select the saturation highlights tone"), (char *)NULL);
// Additional paramters
hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->scale1 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.1, p->balance*100.0, 2);
dt_bauhaus_slider_set_format(g->scale1, "%.2f");
dt_bauhaus_widget_set_label(g->scale1, _("balance"));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
g->scale2 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->compress, 2);
dt_bauhaus_slider_set_format(g->scale2, "%.2f%%");
dt_bauhaus_widget_set_label(g->scale2,_("compress"));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the balance of center of splittoning"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("compress the effect on highlighs/shadows and\npreserve midtones"), (char *)NULL);
g_signal_connect (G_OBJECT (g->gslider1), "value-changed",
G_CALLBACK (hue_callback), self);
g_signal_connect (G_OBJECT (g->gslider3), "value-changed",
G_CALLBACK (hue_callback), self);
g_signal_connect (G_OBJECT (g->gslider2), "value-changed",
G_CALLBACK (saturation_callback), self);
g_signal_connect (G_OBJECT (g->gslider4), "value-changed",
G_CALLBACK (saturation_callback), self);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (balance_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (compress_callback), self);
g_signal_connect (G_OBJECT (g->colorpick1), "clicked",
G_CALLBACK (colorpick_callback), self);
g_signal_connect (G_OBJECT (g->colorpick2), "clicked",
G_CALLBACK (colorpick_callback), self);
}
void _camera_import_dialog_new(_camera_import_dialog_t *data)
{
data->dialog=gtk_dialog_new_with_buttons(_("import images from camera"),NULL,GTK_DIALOG_MODAL,_("cancel"),GTK_RESPONSE_NONE,C_("camera import", "import"),GTK_RESPONSE_ACCEPT,NULL);
GtkWidget *content = gtk_dialog_get_content_area (GTK_DIALOG (data->dialog));
// List - setup store
data->store = gtk_list_store_new (2,GDK_TYPE_PIXBUF,G_TYPE_STRING);
// Setup variables
dt_variables_params_init(&data->vp);
data->vp->jobcode=_("my jobcode");
data->vp->filename="DSC_0235.JPG";
// IMPORT PAGE
data->import.page=gtk_vbox_new(FALSE,5);
gtk_container_set_border_width(GTK_CONTAINER(data->import.page),5);
// Top info
data->import.info=gtk_label_new( _("please wait while prefetching thumbnails of images from camera...") );
gtk_label_set_single_line_mode( GTK_LABEL(data->import.info) , FALSE );
gtk_misc_set_alignment(GTK_MISC(data->import.info), 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(data->import.page),data->import.info,FALSE,FALSE,0);
// jobcode
data->import.jobname=_camera_import_gconf_widget(data,_("jobcode"),"plugins/capture/camera/import/jobcode");
gtk_box_pack_start(GTK_BOX(data->import.page),GTK_WIDGET(data->import.jobname->widget),FALSE,FALSE,0);
// Create the treview with list model data store
data->import.treeview=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->import.treeview),GTK_POLICY_NEVER,GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(data->import.treeview), gtk_tree_view_new());
GtkTreeView *treeview=GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview)));
GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new( );
GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes( _("thumbnail") , renderer,"pixbuf",0, (char *)NULL);
gtk_tree_view_append_column( treeview , column);
renderer = gtk_cell_renderer_text_new( );
column = gtk_tree_view_column_new_with_attributes( _("storage file"), renderer, "text", 1, (char *)NULL);
gtk_tree_view_append_column( treeview , column);
gtk_tree_view_column_set_expand( column, TRUE);
GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection,GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_model(treeview,GTK_TREE_MODEL(data->store));
gtk_tree_view_set_headers_visible(treeview,FALSE);
gtk_box_pack_start(GTK_BOX(data->import.page),data->import.treeview,TRUE,TRUE,0);
// SETTINGS PAGE
data->settings.page=gtk_vbox_new(FALSE,5);
gtk_container_set_border_width(GTK_CONTAINER(data->settings.page),5);
// general settings
gtk_box_pack_start(GTK_BOX(data->settings.page),dtgtk_label_new(_("general"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT),FALSE,FALSE,0);
// ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.
data->settings.general.ignore_jpeg = gtk_check_button_new_with_label (_("ignore JPEG files"));
g_object_set(data->settings.general.ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are raw+JPEG in a directory."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->settings.general.ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs"));
gtk_box_pack_start(GTK_BOX(data->settings.page), data->settings.general.ignore_jpeg, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT(data->settings.general.ignore_jpeg), "clicked",G_CALLBACK (_check_button_callback),data);
GtkWidget *hbox=gtk_hbox_new(FALSE,5);
data->settings.general.date_override=gtk_check_button_new_with_label(_("override today's date"));
gtk_box_pack_start(GTK_BOX(hbox),data->settings.general.date_override,FALSE,FALSE,0);
g_object_set(data->settings.general.date_override,"tooltip-text",_("check this, if you want to override the timestamp used when expanding variables:\n$(YEAR), $(MONTH), $(DAY),\n$(HOUR), $(MINUTE), $(SECONDS)"),(char *)NULL);
data->settings.general.date_entry=gtk_entry_new();
gtk_widget_set_sensitive( data->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override)));
gtk_box_pack_start(GTK_BOX(hbox),data->settings.general.date_entry,TRUE,TRUE,0);
g_signal_connect (G_OBJECT (data->settings.general.date_override), "clicked",G_CALLBACK (_check_button_callback),data);
gtk_box_pack_start(GTK_BOX(data->settings.page),hbox,FALSE,FALSE,0);
// Storage structure
gtk_box_pack_start(GTK_BOX(data->settings.page),dtgtk_label_new(_("storage structure"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT),FALSE,FALSE,0);
GtkWidget *l=gtk_label_new(_("the following three settings describe the directory structure and file renaming for import storage and images; if you don't know how to use this, keep the default settings."));
gtk_label_set_line_wrap(GTK_LABEL(l),TRUE);
gtk_widget_set_size_request(l,400,-1);
gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(data->settings.page),l,FALSE,FALSE,0);
data->settings.basedirectory=_camera_import_gconf_widget(data,_("storage directory"),"plugins/capture/storage/basedirectory");
gtk_box_pack_start(GTK_BOX(data->settings.page),GTK_WIDGET(data->settings.basedirectory->widget),FALSE,FALSE,0);
data->settings.subdirectory=_camera_import_gconf_widget(data,_("directory structure"),"plugins/capture/storage/subpath");
gtk_box_pack_start(GTK_BOX(data->settings.page),GTK_WIDGET(data->settings.subdirectory->widget),FALSE,FALSE,0);
data->settings.namepattern=_camera_import_gconf_widget(data,_("filename structure"),"plugins/capture/storage/namepattern");
gtk_box_pack_start(GTK_BOX(data->settings.page),GTK_WIDGET(data->settings.namepattern->widget),FALSE,FALSE,0);
// Add example
l=gtk_label_new(_("above settings expands to:"));
gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(data->settings.page),l,FALSE,FALSE,0);
data->settings.example=gtk_label_new("");
gtk_label_set_line_wrap(GTK_LABEL(data->settings.example),TRUE);
gtk_widget_set_size_request(data->settings.example,400,-1);
gtk_misc_set_alignment(GTK_MISC(data->settings.example), 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(data->settings.page),data->settings.example,FALSE,FALSE,0);
// External backup
gtk_box_pack_start(GTK_BOX(data->settings.page),dtgtk_label_new(_("external backup"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT),FALSE,FALSE,0);
l=gtk_label_new(_("external backup is an option to automatic do a backup of the imported image(s) to another physical location, when activated it does looks for specified backup foldername of mounted devices on your system... each found folder is used as basedirectory in the above storage structure and when a image are downloaded from camera it is replicated to found backup destinations."));
gtk_label_set_line_wrap(GTK_LABEL(l),TRUE);
gtk_widget_set_size_request(l,400,-1);
gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(data->settings.page),l,FALSE,FALSE,0);
data->settings.backup.enable=gtk_check_button_new_with_label(_("enable backup"));
gtk_box_pack_start(GTK_BOX(data->settings.page),data->settings.backup.enable,FALSE,FALSE,0);
g_object_set(data->settings.backup.enable,"tooltip-text",_("check this option to enable automatic backup of imported images"),(char *)NULL);
data->settings.backup.warn=gtk_check_button_new_with_label(_("warn if no backup destinations are present"));
gtk_box_pack_start(GTK_BOX(data->settings.page),data->settings.backup.warn,FALSE,FALSE,0);
g_object_set(data->settings.backup.warn,"tooltip-text",_("check this option to get an interactive warning if no backupdestinations are present"),(char *)NULL);
data->settings.backup.foldername=(_camera_import_gconf_widget(data,_("backup foldername"),"plugins/capture/camera/backup/foldername"))->widget;
gtk_box_pack_start(GTK_BOX(data->settings.page),data->settings.backup.foldername,FALSE,FALSE,0);
g_object_set(data->settings.backup.foldername,"tooltip-text",_("this is the name of folder that indicates a backup destination,\nif such a folder is found in any mounter media it is used as a backup destination."),(char *)NULL);
if( dt_conf_get_bool("plugins/capture/backup/enable") ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( data->settings.backup.enable ), TRUE);
else
{
gtk_widget_set_sensitive( data->settings.backup.warn, FALSE);
gtk_widget_set_sensitive( data->settings.backup.foldername, FALSE);
}
if( dt_conf_get_bool("plugins/capture/backup/warn") ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( data->settings.backup.warn ), TRUE);
g_signal_connect (G_OBJECT (data->settings.backup.enable), "clicked",G_CALLBACK (_check_button_callback),data);
g_signal_connect (G_OBJECT(data->settings.backup.warn), "clicked",G_CALLBACK (_check_button_callback),data);
// THE NOTEBOOK
data->notebook=gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook),data->import.page,gtk_label_new(_("images")));
gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook),data->settings.page,gtk_label_new(_("settings")));
// end
gtk_box_pack_start(GTK_BOX(content),data->notebook,TRUE,TRUE,0);
//gtk_widget_set_size_request(content,400,400);
_update_example(data);
}
