void gui_init(dt_lib_module_t *self)
{
dt_lib_geotagging_t *d = (dt_lib_geotagging_t *)malloc(sizeof(dt_lib_geotagging_t));
self->data = (void *)d;
d->timezones = _lib_geotagging_get_timezones();
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
GtkBox *hbox;
GtkWidget *button, *label;
/* the offset line */
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
label = GTK_WIDGET(gtk_label_new(_("time offset")));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_box_pack_start(hbox, label, TRUE, TRUE, 0);
d->offset_entry = gtk_entry_new();
dt_gui_key_accel_block_on_focus_connect(d->offset_entry);
gtk_entry_set_max_length(GTK_ENTRY(d->offset_entry), 9);
gtk_entry_set_width_chars(GTK_ENTRY(d->offset_entry), 0);
gtk_box_pack_start(hbox, d->offset_entry, TRUE, TRUE, 0);
g_signal_connect(d->offset_entry, "key-press-event", G_CALLBACK(_lib_geotagging_offset_key_press), self);
g_signal_connect(d->offset_entry, "focus-out-event", G_CALLBACK(_lib_geotagging_offset_focus_out), self);
g_object_set(G_OBJECT(d->offset_entry), "tooltip-text", _("time offset\nformat: [+-]?[[hh:]mm:]ss"),
(char *)NULL);
gchar *str = dt_conf_get_string("plugins/lighttable/geotagging/offset");
if(_lib_geotagging_parse_offset(str, NULL))
gtk_entry_set_text(GTK_ENTRY(d->offset_entry), str);
else
gtk_entry_set_text(GTK_ENTRY(d->offset_entry), "+00:00:00");
g_free(str);
GtkBox *button_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
button = dtgtk_button_new(dtgtk_cairo_paint_zoom, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
g_object_set(G_OBJECT(button), "tooltip-text", _("calculate the time offset from an image"), (char *)NULL);
gtk_box_pack_start(button_box, button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_lib_geotagging_show_offset_window), self);
button = dtgtk_button_new(dtgtk_cairo_paint_check_mark, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
g_object_set(G_OBJECT(button), "tooltip-text", _("apply time offset to selected images"), (char *)NULL);
gtk_box_pack_start(button_box, button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_lib_geotagging_apply_offset_callback), self);
gtk_box_pack_start(hbox, GTK_WIDGET(button_box), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
/* gpx */
button = gtk_button_new_with_label(_("apply GPX track file"));
g_object_set(G_OBJECT(button), "tooltip-text",
_("parses a GPX file and updates location of selected images"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_lib_geotagging_gpx_callback), self);
}
/** Creates a gconf widget. */
_camera_gconf_widget_t *_camera_import_gconf_widget(_camera_import_dialog_t *dlg,gchar *label,gchar *confstring)
{
_camera_gconf_widget_t *gcw=malloc(sizeof(_camera_gconf_widget_t));
memset(gcw,0,sizeof(_camera_gconf_widget_t));
GtkWidget *vbox,*hbox;
gcw->widget=vbox=GTK_WIDGET(gtk_vbox_new(FALSE,0));
hbox=GTK_WIDGET(gtk_hbox_new(FALSE,0));
g_object_set_data(G_OBJECT(vbox),"gconf:string",confstring);
gcw->dialog=dlg;
gcw->entry=gtk_entry_new();
char* value = dt_conf_get_string(confstring);
if(value)
{
gtk_entry_set_text( GTK_ENTRY( gcw->entry ), value);
if(gcw->value)
g_free(gcw->value);
gcw->value = value;
}
gtk_box_pack_start(GTK_BOX(hbox),GTK_WIDGET(gcw->entry),TRUE,TRUE,0);
GtkWidget *button=dtgtk_button_new(dtgtk_cairo_paint_store,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
g_object_set(button,"tooltip-text",_("store value as default"),(char *)NULL);
gtk_widget_set_size_request(button,13,13);
gtk_box_pack_start(GTK_BOX(hbox),button,FALSE,FALSE,0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (_gcw_store_callback), gcw);
button=dtgtk_button_new(dtgtk_cairo_paint_reset,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
g_object_set(button,"tooltip-text",_("reset value to default"),(char *)NULL);
gtk_widget_set_size_request(button,13,13);
gtk_box_pack_start(GTK_BOX(hbox),button,FALSE,FALSE,0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (_gcw_reset_callback), gcw);
GtkWidget *l=gtk_label_new(label);
gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(vbox),l,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),GTK_WIDGET(hbox),FALSE,FALSE,0);
g_signal_connect (G_OBJECT(gtk_entry_get_buffer(GTK_ENTRY(gcw->entry))), "inserted-text",
G_CALLBACK (entry_it_callback), gcw);
g_signal_connect (G_OBJECT(gtk_entry_get_buffer(GTK_ENTRY(gcw->entry))), "deleted-text",
G_CALLBACK (entry_dt_callback), gcw);
return gcw;
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_colorlabels_t *d = (dt_lib_colorlabels_t *)g_malloc0(sizeof(dt_lib_colorlabels_t));
self->data = (void *)d;
/* setup list of tooltips */
d->tooltips[0] = _("toggle red label\nof selected images");
d->tooltips[1] = _("toggle yellow label\nof selected images");
d->tooltips[2] = _("toggle green label\nof selected images");
d->tooltips[3] = _("toggle blue label\nof selected images");
d->tooltips[4] = _("toggle purple label\nof selected images");
d->tooltips[5] = _("clear all labels of selected images");
/* create buttons */
self->widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *button;
for(int k = 0; k < 6; k++)
{
button = dtgtk_button_new(dtgtk_cairo_paint_label, (k | 8 | CPF_BG_TRANSPARENT | CPF_DO_NOT_USE_BORDER), NULL);
d->buttons[k] = button;
gtk_widget_set_size_request(button, DT_PIXEL_APPLY_DPI(16), DT_PIXEL_APPLY_DPI(16));
gtk_widget_set_tooltip_text(button, d->tooltips[k]);
gtk_box_pack_start(GTK_BOX(self->widget), button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_lib_colorlabels_button_clicked_callback),
GINT_TO_POINTER(k));
}
}
void
gui_init (dt_lib_module_t *self)
{
dt_lib_recentcollect_t *d = (dt_lib_recentcollect_t *)malloc(sizeof(dt_lib_recentcollect_t));
memset(d,0,sizeof(dt_lib_recentcollect_t));
self->data = (void *)d;
self->widget = gtk_vbox_new(FALSE, 0);
d->inited = 0;
// add buttons in the list, set them all to invisible
for(int k=0; k<NUM_LINES; k++)
{
d->item[k].button = dtgtk_button_new(NULL, CPF_STYLE_FLAT);
gtk_box_pack_start(GTK_BOX(self->widget), d->item[k].button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(d->item[k].button), "clicked", G_CALLBACK(button_pressed), (gpointer)self);
gtk_widget_set_no_show_all(d->item[k].button, TRUE);
gtk_widget_set_visible(d->item[k].button, FALSE);
}
_lib_recentcollection_updated(NULL,self);
/* connect collection changed signal */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_COLLECTION_CHANGED,
G_CALLBACK(_lib_recentcollection_updated),
(gpointer)self);
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_colorlabels_t *d = (dt_lib_colorlabels_t *)g_malloc(sizeof(dt_lib_colorlabels_t));
self->data = (void *)d;
memset(d,0,sizeof(dt_lib_colorlabels_t));
/* setup list of tooltips */
d->tooltips[0] = _("toggle red label\nof selected images (f1)");
d->tooltips[1] = _("toggle yellow label\nof selected images (f2)");
d->tooltips[2] = _("toggle green label\nof selected images (f3)");
d->tooltips[3] = _("toggle blue label\nof selected images (f4)");
d->tooltips[4] = _("toggle purple label\nof selected images (f5)");
d->tooltips[5] = _("clear all labels of selected images");
/* create buttons */
self->widget = gtk_hbox_new(FALSE,0);
GtkWidget *button;
for(long k = 0; k < 6; k++)
{
button = dtgtk_button_new(dtgtk_cairo_paint_label, (k|8|CPF_BG_TRANSPARENT|CPF_DO_NOT_USE_BORDER));
gtk_widget_set_size_request(button,16,16);
g_object_set(G_OBJECT(button), "tooltip-text", d->tooltips[k], (gpointer)0);
gtk_box_pack_start(GTK_BOX(self->widget), button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_lib_colorlabels_button_clicked_callback), (gpointer)k);
}
}
void
gui_init (dt_imageio_module_storage_t *self)
{
disk_t *d = (disk_t *)malloc(sizeof(disk_t));
self->gui_data = (void *)d;
self->widget = gtk_hbox_new(FALSE, 5);
GtkWidget *widget;
widget = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(self->widget), widget, TRUE, TRUE, 0);
gchar *dir = dt_conf_get_string("plugins/imageio/storage/disk/file_directory");
if(dir)
{
gtk_entry_set_text(GTK_ENTRY(widget), dir);
g_free(dir);
}
dt_gtkentry_setup_completion(GTK_ENTRY(widget), dt_gtkentry_get_default_path_compl_list());
char *tooltip_text = dt_gtkentry_build_completion_tooltip_text (
_("enter the path where to put exported images\nrecognized variables:"),
dt_gtkentry_get_default_path_compl_list());
d->entry = GTK_ENTRY(widget);
dt_gui_key_accel_block_on_focus (GTK_WIDGET (d->entry));
g_object_set(G_OBJECT(widget), "tooltip-text", tooltip_text, (char *)NULL);
widget = dtgtk_button_new(dtgtk_cairo_paint_directory, 0);
gtk_widget_set_size_request(widget, 18, 18);
g_object_set(G_OBJECT(widget), "tooltip-text", _("select directory"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(button_clicked), self);
g_free(tooltip_text);
}
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);
}
/** Creates a gconf widget. */
static _camera_gconf_widget_t *_camera_import_gconf_widget(_camera_import_dialog_t *dlg, gchar *label,
gchar *confstring)
{
_camera_gconf_widget_t *gcw = calloc(1, sizeof(_camera_gconf_widget_t));
GtkWidget *vbox, *hbox;
gcw->widget = vbox = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
hbox = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
g_object_set_data(G_OBJECT(vbox), "gconf:string", confstring);
gcw->dialog = dlg;
gcw->entry = gtk_entry_new();
char *value = dt_conf_get_string(confstring);
if(value)
{
gtk_entry_set_text(GTK_ENTRY(gcw->entry), value);
g_free(gcw->value);
gcw->value = value;
}
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(gcw->entry), TRUE, TRUE, 0);
GtkWidget *button = dtgtk_button_new(dtgtk_cairo_paint_store, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
gtk_widget_set_tooltip_text(button, _("store value as default"));
gtk_widget_set_size_request(button, DT_PIXEL_APPLY_DPI(13), DT_PIXEL_APPLY_DPI(13));
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_gcw_store_callback), gcw);
button = dtgtk_button_new(dtgtk_cairo_paint_reset, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
gtk_widget_set_tooltip_text(button, _("reset value to default"));
gtk_widget_set_size_request(button, DT_PIXEL_APPLY_DPI(13), DT_PIXEL_APPLY_DPI(13));
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_gcw_reset_callback), gcw);
GtkWidget *l = gtk_label_new(label);
gtk_widget_set_halign(l, GTK_ALIGN_START);
gtk_box_pack_start(GTK_BOX(vbox), l, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(gtk_entry_get_buffer(GTK_ENTRY(gcw->entry))), "inserted-text",
G_CALLBACK(entry_it_callback), gcw);
g_signal_connect(G_OBJECT(gtk_entry_get_buffer(GTK_ENTRY(gcw->entry))), "deleted-text",
G_CALLBACK(entry_dt_callback), gcw);
return gcw;
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_history_t *d = (dt_lib_history_t *)g_malloc0(sizeof(dt_lib_history_t));
self->data = (void *)d;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_name(self->widget, "history-ui");
d->history_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *hhbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5));
GtkWidget *hbutton = dtgtk_button_new(NULL, /*CPF_DO_NOT_USE_BORDER | CPF_STYLE_FLAT*/0);
gtk_button_set_label(GTK_BUTTON(hbutton), _("compress history stack"));
d->compress_button = hbutton;
g_object_set(G_OBJECT(hbutton), "tooltip-text",
_("create a minimal history stack which produces the same image"), (char *)NULL);
g_signal_connect(G_OBJECT(hbutton), "clicked", G_CALLBACK(_lib_history_compress_clicked_callback), NULL);
/* add toolbar button for creating style */
GtkWidget *hbutton2 = dtgtk_button_new(dtgtk_cairo_paint_styles, CPF_DO_NOT_USE_BORDER);
gtk_widget_set_size_request (hbutton2, DT_PIXEL_APPLY_DPI(24), -1);
g_signal_connect(G_OBJECT(hbutton2), "clicked",
G_CALLBACK(_lib_history_create_style_button_clicked_callback), NULL);
g_object_set(G_OBJECT(hbutton2), "tooltip-text", _("create a style from the current history stack"),
(char *)NULL);
d->create_button = hbutton2;
/* add buttons to buttonbox */
gtk_box_pack_start(GTK_BOX(hhbox), hbutton, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hhbox), hbutton2, FALSE, FALSE, 0);
/* add history list and buttonbox to widget */
gtk_box_pack_start(GTK_BOX(self->widget), d->history_box, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), hhbox, FALSE, FALSE, 0);
gtk_widget_show_all(self->widget);
/* connect to history change signal for updating the history view */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_HISTORY_CHANGE,
G_CALLBACK(_lib_history_change_callback), self);
}
GtkWidget*
dtgtk_button_new_with_label (const gchar *label, DTGTKCairoPaintIconFunc paint, gint paintflags)
{
GtkWidget *button = dtgtk_button_new (paint,paintflags);
/* set button label */
gtk_button_set_label (GTK_BUTTON (button),label);
return button;
}
void gui_init(dt_imageio_module_storage_t *self)
{
latex_t *d = (latex_t *)malloc(sizeof(latex_t));
self->gui_data = (void *)d;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
gtk_box_pack_start(GTK_BOX(self->widget), hbox, TRUE, TRUE, 0);
GtkWidget *widget;
widget = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gchar *dir = dt_conf_get_string("plugins/imageio/storage/latex/file_directory");
if(dir)
{
gtk_entry_set_text(GTK_ENTRY(widget), dir);
g_free(dir);
}
d->entry = GTK_ENTRY(widget);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry));
dt_gtkentry_setup_completion(GTK_ENTRY(widget), dt_gtkentry_get_default_path_compl_list());
char *tooltip_text = dt_gtkentry_build_completion_tooltip_text(
_("enter the path where to put exported images\nrecognized variables:"),
dt_gtkentry_get_default_path_compl_list());
gtk_widget_set_tooltip_text(widget, tooltip_text);
g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(entry_changed_callback), self);
g_free(tooltip_text);
widget = dtgtk_button_new(dtgtk_cairo_paint_directory, CPF_DO_NOT_USE_BORDER);
gtk_widget_set_tooltip_text(widget, _("select directory"));
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(button_clicked), self);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
gtk_box_pack_start(GTK_BOX(self->widget), hbox, TRUE, TRUE, 0);
widget = gtk_label_new(_("title"));
gtk_widget_set_halign(widget, GTK_ALIGN_START);
g_object_set(G_OBJECT(widget), "xalign", 0.0, NULL);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
d->title_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(d->title_entry), TRUE, TRUE, 0);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->title_entry));
// TODO: support title, author, subject, keywords (collect tags?)
gtk_widget_set_tooltip_text(GTK_WIDGET(d->title_entry), _("enter the title of the book"));
dir = dt_conf_get_string("plugins/imageio/storage/latex/title");
if(dir)
{
gtk_entry_set_text(GTK_ENTRY(d->title_entry), dir);
g_free(dir);
}
g_signal_connect(G_OBJECT(d->title_entry), "changed", G_CALLBACK(title_changed_callback), self);
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_duplicate_t *d = (dt_lib_duplicate_t *)g_malloc0(sizeof(dt_lib_duplicate_t));
self->data = (void *)d;
d->imgid = 0;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_name(self->widget, "duplicate-ui");
GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sw), DT_PIXEL_APPLY_DPI(300));
d->duplicate_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *bt = gtk_label_new(_("existing duplicates"));
gtk_box_pack_start(GTK_BOX(hb), bt, FALSE, FALSE, 0);
bt = dtgtk_button_new(dtgtk_cairo_paint_plusminus, CPF_ACTIVE | CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
g_object_set(G_OBJECT(bt), "tooltip-text", _("create a 'virgin' duplicate of the image without any developpement"), (char *)NULL);
g_signal_connect(G_OBJECT(bt), "button-press-event", G_CALLBACK(_lib_duplicate_new_clicked_callback), self);
gtk_box_pack_end(GTK_BOX(hb), bt, FALSE, FALSE, 0);
bt = dtgtk_button_new(dtgtk_cairo_paint_multiinstance, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
g_object_set(G_OBJECT(bt), "tooltip-text", _("create a duplicate of the image with same history stack"), (char *)NULL);
g_signal_connect(G_OBJECT(bt), "button-press-event", G_CALLBACK(_lib_duplicate_duplicate_clicked_callback), self);
gtk_box_pack_end(GTK_BOX(hb), bt, FALSE, FALSE, 0);
/* add duplicate list and buttonbox to widget */
gtk_box_pack_start(GTK_BOX(self->widget), hb, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(sw), d->duplicate_box);
gtk_box_pack_start(GTK_BOX(self->widget), sw, FALSE, FALSE, 0);
gtk_widget_show_all(self->widget);
dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_IMAGE_CHANGED, G_CALLBACK(_lib_duplicate_init_callback), self);
dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_INITIALIZE, G_CALLBACK(_lib_duplicate_init_callback), self);
dt_control_signal_connect(darktable.signals, DT_SIGNAL_COLLECTION_CHANGED,
G_CALLBACK(_lib_duplicate_init_callback), self);
dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_MIPMAP_UPDATED, G_CALLBACK(_lib_duplicate_mipmap_updated_callback), (gpointer)self);
}
void
gui_init (dt_imageio_module_storage_t *self)
{
disk_t *d = (disk_t *)malloc(sizeof(disk_t));
self->gui_data = (void *)d;
self->widget = gtk_hbox_new(FALSE, 5);
GtkWidget *widget;
widget = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(self->widget), widget, TRUE, TRUE, 0);
gchar *dir = dt_conf_get_string("plugins/imageio/storage/disk/file_directory");
if(dir)
{
gtk_entry_set_text(GTK_ENTRY(widget), dir);
g_free(dir);
}
d->entry = GTK_ENTRY(widget);
dt_gui_key_accel_block_on_focus (GTK_WIDGET (d->entry));
g_object_set(G_OBJECT(widget), "tooltip-text", _("enter the path where to put exported images:\n"
"$(ROLL_NAME) - roll of the input image\n"
"$(FILE_DIRECTORY) - directory of the input image\n"
"$(FILE_NAME) - basename of the input image\n"
"$(FILE_EXTENSION) - extension of the input image\n"
"$(SEQUENCE) - sequence number\n"
"$(YEAR) - year\n"
"$(MONTH) - month\n"
"$(DAY) - day\n"
"$(HOUR) - hour\n"
"$(MINUTE) - minute\n"
"$(SECOND) - second\n"
"$(EXIF_YEAR) - exif year\n"
"$(EXIF_MONTH) - exif month\n"
"$(EXIF_DAY) - exif day\n"
"$(EXIF_HOUR) - exif hour\n"
"$(EXIF_MINUTE) - exif minute\n"
"$(EXIF_SECOND) - exif second\n"
"$(STARS) - star rating\n"
"$(LABELS) - colorlabels\n"
"$(PICTURES_FOLDER) - pictures folder\n"
"$(HOME_FOLDER) - home folder\n"
"$(DESKTOP_FOLDER) - desktop folder"
), (char *)NULL);
widget = dtgtk_button_new(dtgtk_cairo_paint_directory, 0);
gtk_widget_set_size_request(widget, 18, 18);
g_object_set(G_OBJECT(widget), "tooltip-text", _("select directory"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(button_clicked), self);
}
void gui_init(dt_imageio_module_storage_t *self)
{
disk_t *d = (disk_t *)malloc(sizeof(disk_t));
self->gui_data = (void *)d;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
GtkWidget *widget;
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, FALSE, 0);
widget = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gchar *dir = dt_conf_get_string("plugins/imageio/storage/disk/file_directory");
if(dir)
{
gtk_entry_set_text(GTK_ENTRY(widget), dir);
g_free(dir);
}
dt_gtkentry_setup_completion(GTK_ENTRY(widget), dt_gtkentry_get_default_path_compl_list());
char *tooltip_text = dt_gtkentry_build_completion_tooltip_text(
_("enter the path where to put exported images\nvariables support bash like string manipulation\n"
"recognized variables:"),
dt_gtkentry_get_default_path_compl_list());
d->entry = GTK_ENTRY(widget);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry));
gtk_entry_set_width_chars(GTK_ENTRY(widget), 0);
gtk_widget_set_tooltip_text(widget, tooltip_text);
g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(entry_changed_callback), self);
widget = dtgtk_button_new(dtgtk_cairo_paint_directory, CPF_DO_NOT_USE_BORDER, NULL);
gtk_widget_set_size_request(widget, DT_PIXEL_APPLY_DPI(18), DT_PIXEL_APPLY_DPI(18));
gtk_widget_set_tooltip_text(widget, _("select directory"));
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(button_clicked), self);
d->overwrite = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(d->overwrite, NULL, _("on conflict"));
dt_bauhaus_combobox_add(d->overwrite, _("create unique filename"));
dt_bauhaus_combobox_add(d->overwrite, _("overwrite"));
gtk_box_pack_start(GTK_BOX(self->widget), d->overwrite, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(d->overwrite), "value-changed", G_CALLBACK(overwrite_toggle_callback), self);
dt_bauhaus_combobox_set(d->overwrite, 0);
g_free(tooltip_text);
}
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)
{
/* 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_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_button_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);
}
static void _lib_backgroundjobs_set_cancellable(dt_lib_module_t *self, const guint *key, struct dt_job_t *job)
{
if(!darktable.control->running) return;
gboolean i_own_lock = dt_control_gdk_lock();
dt_lib_backgroundjobs_t *d = (dt_lib_backgroundjobs_t*)self->data;
dt_bgjob_t *j = (dt_bgjob_t*)g_hash_table_lookup(d->jobs, key);
if (j)
{
GtkWidget *w=j->widget;
GtkBox *hbox = GTK_BOX (g_list_nth_data (gtk_container_get_children (GTK_CONTAINER ( gtk_bin_get_child (GTK_BIN (w) ) ) ), 0));
GtkWidget *button = dtgtk_button_new(dtgtk_cairo_paint_cancel,CPF_STYLE_FLAT);
gtk_widget_set_size_request(button,17,17);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (_lib_backgroundjobs_cancel_callback), (gpointer)job);
gtk_box_pack_start (hbox, GTK_WIDGET(button), FALSE, FALSE, 0);
gtk_widget_show_all(button);
}
if(i_own_lock) dt_control_gdk_unlock();
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_history_t *d = (dt_lib_history_t *)g_malloc(sizeof(dt_lib_history_t));
self->data = (void *)d;
memset(d,0,sizeof(dt_lib_history_t));
self->widget = gtk_vbox_new (FALSE,2);
d->history_box = gtk_vbox_new(FALSE,0);
GtkWidget *hhbox = gtk_hbox_new (FALSE,2);
GtkWidget *hbutton = gtk_button_new_with_label (_("compress history stack"));
d->compress_button = hbutton;
g_object_set (G_OBJECT (hbutton), "tooltip-text", _("create a minimal history stack which produces the same image"), (char *)NULL);
g_signal_connect (G_OBJECT (hbutton), "clicked", G_CALLBACK (_lib_history_compress_clicked_callback),(gpointer)0);
/* add toolbar button for creating style */
GtkWidget *hbutton2 = dtgtk_button_new (dtgtk_cairo_paint_styles,0);
//gtk_widget_set_size_request (hbutton,24,-1);
g_signal_connect (G_OBJECT (hbutton2), "clicked", G_CALLBACK (_lib_history_create_style_button_clicked_callback),(gpointer)0);
g_object_set (G_OBJECT (hbutton2), "tooltip-text", _("create a style from the current history stack"), (char *)NULL);
d->create_button = hbutton2;
/* add buttons to buttonbox */
gtk_box_pack_start (GTK_BOX (hhbox),hbutton,TRUE,TRUE,0);
gtk_box_pack_start (GTK_BOX (hhbox),hbutton2,FALSE,FALSE,0);
/* add history list and buttonbox to widget */
gtk_box_pack_start (GTK_BOX (self->widget),d->history_box,FALSE,FALSE,0);
gtk_box_pack_start (GTK_BOX (self->widget),hhbox,FALSE,FALSE,0);
gtk_widget_show_all (self->widget);
/* connect to history change signal for updating the history view */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_HISTORY_CHANGE, G_CALLBACK(_lib_history_change_callback), self);
}
void
gui_init (dt_lib_module_t *self)
{
dt_lib_collect_t *d = (dt_lib_collect_t *)malloc(sizeof(dt_lib_collect_t));
self->data = (void *)d;
self->widget = gtk_vbox_new(FALSE, 5);
gtk_widget_set_size_request(self->widget, 100, -1);
d->active_rule = 0;
d->params = (dt_lib_collect_params_t*)malloc(sizeof(dt_lib_collect_params_t));
dt_control_signal_connect(darktable.signals,
DT_SIGNAL_COLLECTION_CHANGED,
G_CALLBACK(collection_updated),
self);
GtkBox *box;
GtkWidget *w;
GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL);
GtkTreeView *view = GTK_TREE_VIEW(gtk_tree_view_new());
d->view = view;
GtkListStore *liststore;
for(int i=0; i<MAX_RULES; i++)
{
d->rule[i].num = i;
box = GTK_BOX(gtk_hbox_new(FALSE, 5));
d->rule[i].hbox = GTK_WIDGET(box);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0);
w = gtk_combo_box_new_text();
d->rule[i].combo = GTK_COMBO_BOX(w);
for(int k=0; k<dt_lib_collect_string_cnt; k++)
gtk_combo_box_append_text(GTK_COMBO_BOX(w), _(dt_lib_collect_string[k]));
g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(combo_changed), d->rule + i);
gtk_box_pack_start(box, w, FALSE, FALSE, 0);
w = gtk_entry_new();
dt_gui_key_accel_block_on_focus(w);
d->rule[i].text = w;
gtk_widget_add_events(w, GDK_FOCUS_CHANGE_MASK);
g_signal_connect(G_OBJECT(w), "focus-in-event", G_CALLBACK(entry_focus_in_callback), d->rule + i);
/* xgettext:no-c-format */
g_object_set(G_OBJECT(w), "tooltip-text", _("type your query, use `%' as wildcard"), (char *)NULL);
gtk_widget_add_events(w, GDK_KEY_PRESS_MASK);
g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(changed_callback), d->rule + i);
g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(entry_activated), d->rule + i);
gtk_box_pack_start(box, w, TRUE, TRUE, 0);
w = dtgtk_button_new(dtgtk_cairo_paint_presets, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER);
d->rule[i].button = w;
gtk_widget_set_events(w, GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(w), "button-press-event", G_CALLBACK(popup_button_callback), d->rule + i);
gtk_box_pack_start(box, w, FALSE, FALSE, 0);
gtk_widget_set_size_request(w, 13, 13);
}
d->scrolledwindow = GTK_SCROLLED_WINDOW(sw);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(sw), GTK_WIDGET(view));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(sw), TRUE, TRUE, 0);
gtk_tree_view_set_headers_visible(view, FALSE);
liststore = gtk_list_store_new(DT_LIB_COLLECT_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING);
GtkTreeViewColumn *col = gtk_tree_view_column_new();
gtk_tree_view_append_column(view, col);
gtk_widget_set_size_request(GTK_WIDGET(view), -1, 300);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_COLLECT_COL_TEXT);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(view), GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(view, GTK_TREE_MODEL(liststore));
g_signal_connect(G_OBJECT (view), "row-activated", G_CALLBACK (row_activated), d);
/* setup proxy */
darktable.view_manager->proxy.module_collect.module = self;
darktable.view_manager->proxy.module_collect.update = _lib_collect_gui_update;
_lib_collect_gui_update(self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_borders_gui_data_t));
dt_iop_borders_gui_data_t *g = (dt_iop_borders_gui_data_t *)self->gui_data;
dt_iop_borders_params_t *p = (dt_iop_borders_params_t *)self->params;
self->widget = gtk_vbox_new(FALSE, DT_BAUHAUS_SPACE);
g->size = dt_bauhaus_slider_new_with_range(self, 0.0, 50.0, 0.5, p->size*100.0, 2);
dt_bauhaus_widget_set_label(g->size, NULL, _("border size"));
dt_bauhaus_slider_set_format(g->size, "%.2f%%");
g_signal_connect (G_OBJECT (g->size), "value-changed", G_CALLBACK (size_callback), self);
g_object_set(G_OBJECT(g->size), "tooltip-text", _("size of the border in percent of the full image"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), g->size, TRUE, TRUE, 0);
g->aspect = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->aspect, 1);
dt_bauhaus_widget_set_label(g->aspect, NULL, _("aspect"));
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect, TRUE, TRUE, 0);
gui_init_aspect(self);
g_signal_connect (G_OBJECT (g->aspect), "value-changed", G_CALLBACK (aspect_changed), self);
g_object_set(G_OBJECT(g->aspect), "tooltip-text", _("select the aspect ratio or right click and type your own (w:h)"), (char *)NULL);
g->aspect_orient = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->aspect_orient, NULL, _("orientation"));
dt_bauhaus_combobox_add(g->aspect_orient, _("auto"));
dt_bauhaus_combobox_add(g->aspect_orient, _("portrait"));
dt_bauhaus_combobox_add(g->aspect_orient, _("landscape"));
g_object_set(G_OBJECT(g->aspect_orient), "tooltip-text", _("aspect ratio orientation of the image with border"), (char *)NULL);
g_signal_connect (G_OBJECT (g->aspect_orient), "value-changed", G_CALLBACK (aspect_orient_changed), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect_orient, TRUE, TRUE, 0);
g->pos_h = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->pos_h, 1);
dt_bauhaus_widget_set_label(g->pos_h, NULL, _("horizontal position"));
gtk_box_pack_start(GTK_BOX(self->widget), g->pos_h, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (g->pos_h), "value-changed", G_CALLBACK (position_h_changed), self);
g_object_set(G_OBJECT(g->pos_h), "tooltip-text", _("select the horizontal position ratio relative to top or right click and type your own (y:h)"), (char *)NULL);
g->pos_v = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->pos_v, 1);
dt_bauhaus_widget_set_label(g->pos_v, NULL, _("vertical position"));
gtk_box_pack_start(GTK_BOX(self->widget), g->pos_v, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (g->pos_v), "value-changed", G_CALLBACK (position_v_changed), self);
g_object_set(G_OBJECT(g->pos_v), "tooltip-text", _("select the vertical position ratio relative to left or right click and type your own (x:w)"), (char *)NULL);
gui_init_positions(self);
g->frame_size = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_size*100.0, 2);
dt_bauhaus_widget_set_label(g->frame_size, NULL, _("frame line size"));
dt_bauhaus_slider_set_format(g->frame_size, "%.2f%%");
g_signal_connect (G_OBJECT (g->frame_size), "value-changed", G_CALLBACK (frame_size_callback), self);
g_object_set(G_OBJECT(g->frame_size), "tooltip-text", _("size of the frame line in percent of min border width"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), g->frame_size, TRUE, TRUE, 0);
g->frame_offset = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_offset*100.0, 2);
dt_bauhaus_widget_set_label(g->frame_offset, NULL, _("frame line offset"));
dt_bauhaus_slider_set_format(g->frame_offset, "%.2f%%");
g_signal_connect (G_OBJECT (g->frame_offset), "value-changed", G_CALLBACK (frame_offset_callback), self);
g_object_set(G_OBJECT(g->frame_offset), "tooltip-text", _("offset of the frame line beginning on picture side"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), g->frame_offset, TRUE, TRUE, 0);
GtkWidget *box = gtk_hbox_new(FALSE, 0);
g->colorpick = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color, CPF_IGNORE_FG_STATE | CPF_STYLE_FLAT));
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), 24, 24);
GtkWidget *label = dtgtk_reset_label_new (_("border color"), self, &p->color, 3*sizeof(float));
g_signal_connect (G_OBJECT (g->colorpick), "clicked", G_CALLBACK (colorpick_callback), self);
g->border_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
g_object_set(G_OBJECT(g->border_picker), "tooltip-text", _("pick border color from image"), (char *)NULL);
gtk_widget_set_size_request(GTK_WIDGET(g->border_picker), 24, 24);
g_signal_connect(G_OBJECT(g->border_picker), "toggled", G_CALLBACK(request_pick_toggled_border), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->border_picker), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
box = gtk_hbox_new(FALSE, 0);
g->frame_colorpick = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color, CPF_IGNORE_FG_STATE | CPF_STYLE_FLAT));
gtk_widget_set_size_request(GTK_WIDGET(g->frame_colorpick), 24, 24);
label = dtgtk_reset_label_new (_("frame line color"), self, &p->color, 3*sizeof(float));
g_signal_connect (G_OBJECT (g->frame_colorpick), "clicked", G_CALLBACK (frame_colorpick_callback), self);
g->frame_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
g_object_set(G_OBJECT(g->frame_picker), "tooltip-text", _("pick frame line color from image"), (char *)NULL);
gtk_widget_set_size_request(GTK_WIDGET(g->frame_picker), 24, 24);
g_signal_connect(G_OBJECT(g->frame_picker), "toggled", G_CALLBACK(request_pick_toggled_frame), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_picker), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT(self->widget), "expose-event", G_CALLBACK(borders_expose), self);
}
void
gui_init (dt_imageio_module_storage_t *self)
{
gallery_t *d = (gallery_t *)malloc(sizeof(gallery_t));
self->gui_data = (void *)d;
self->widget = gtk_vbox_new(TRUE, 5);
GtkWidget *hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox, TRUE, TRUE, 0);
GtkWidget *widget;
widget = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gchar *dir = dt_conf_get_string("plugins/imageio/storage/gallery/file_directory");
if(dir)
{
gtk_entry_set_text(GTK_ENTRY(widget), dir);
g_free(dir);
}
d->entry = GTK_ENTRY(widget);
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (d->entry));
dt_gtkentry_completion_spec compl_list[] =
{
{ "ROLL_NAME", _("$(ROLL_NAME) - roll of the input image") },
{ "FILE_FOLDER", _("$(FILE_FOLDER) - folder containing the input image") },
{ "FILE_NAME", _("$(FILE_NAME) - basename of the input image") },
{ "FILE_EXTENSION", _("$(FILE_EXTENSION) - extension of the input image") },
{ "SEQUENCE", _("$(SEQUENCE) - sequence number") },
{ "YEAR", _("$(YEAR) - year") },
{ "MONTH", _("$(MONTH) - month") },
{ "DAY", _("$(DAY) - day") },
{ "HOUR", _("$(HOUR) - hour") },
{ "MINUTE", _("$(MINUTE) - minute") },
{ "SECOND", _("$(SECOND) - second") },
{ "EXIF_YEAR", _("$(EXIF_YEAR) - exif year") },
{ "EXIF_MONTH", _("$(EXIF_MONTH) - exif month") },
{ "EXIF_DAY", _("$(EXIF_DAY) - exif day") },
{ "EXIF_HOUR", _("$(EXIF_HOUR) - exif hour") },
{ "EXIF_MINUTE", _("$(EXIF_MINUTE) - exif minute") },
{ "EXIF_SECOND", _("$(EXIF_SECOND) - exif second") },
{ "STARS", _("$(STARS) - star rating") },
{ "LABELS", _("$(LABELS) - colorlabels") },
{ "PICTURES_FOLDER", _("$(PICTURES_FOLDER) - pictures folder") },
{ "HOME", _("$(HOME) - home folder") },
{ "DESKTOP", _("$(DESKTOP) - desktop folder") },
{ NULL, NULL }
};
dt_gtkentry_setup_completion(GTK_ENTRY(widget), compl_list);
char *tooltip_text = dt_gtkentry_build_completion_tooltip_text (
_("enter the path where to put exported images\nrecognized variables:"),
compl_list);
g_object_set(G_OBJECT(widget), "tooltip-text", tooltip_text, (char *)NULL);
g_free(tooltip_text);
widget = dtgtk_button_new(dtgtk_cairo_paint_directory, 0);
gtk_widget_set_size_request(widget, 18, 18);
g_object_set(G_OBJECT(widget), "tooltip-text", _("select directory"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(button_clicked), self);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox, TRUE, TRUE, 0);
widget = gtk_label_new(_("title"));
gtk_misc_set_alignment(GTK_MISC(widget), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
d->title_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(d->title_entry), TRUE, TRUE, 0);
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (d->title_entry));
g_object_set(G_OBJECT(d->title_entry), "tooltip-text", _("enter the title of the website"), (char *)NULL);
dir = dt_conf_get_string("plugins/imageio/storage/gallery/title");
if(dir)
{
gtk_entry_set_text(GTK_ENTRY(d->title_entry), dir);
g_free(dir);
}
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_colorize_gui_data_t));
dt_iop_colorize_gui_data_t *g = (dt_iop_colorize_gui_data_t *)self->gui_data;
dt_iop_colorize_params_t *p = (dt_iop_colorize_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, 0));
g->colorpick1 = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color,CPF_IGNORE_FG_STATE|CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick1),32,32);
GtkWidget *hbox = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox1 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_end(GTK_BOX(hbox),GTK_WIDGET(g->colorpick1),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->label1 = dtgtk_reset_label_new (_("hue"), self, &p->hue, sizeof(float));
g->label2 = dtgtk_reset_label_new (_("saturation"), self, &p->saturation, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label2), TRUE, TRUE, 0);
int lightness=32768;
g->gslider1 = DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,0,0
},(GdkColor)
{
0,lightness,0,0
}));
dtgtk_gradient_slider_set_stop(g->gslider1,0.166,(GdkColor)
{
0,lightness,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.332,(GdkColor)
{
0,0,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.498,(GdkColor)
{
0,0,lightness,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.664,(GdkColor)
{
0,0,0,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.83,(GdkColor)
{
0,lightness,0,lightness
});
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider1), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider1), "tooltip-text", _("select the hue tone"), (char *)NULL);
g->gslider2=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,lightness,lightness
},(GdkColor)
{
0,lightness,lightness,lightness
}));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider2), "tooltip-text", _("select the saturation shadow tone"), (char *)NULL);
// Additional paramters
hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 100.0, 0.1, p->lightness*100.0, 2));
dtgtk_slider_set_format_type(g->scale1,DARKTABLE_SLIDER_FORMAT_PERCENT);
dtgtk_slider_set_label(g->scale1,_("lightness"));
dtgtk_slider_set_unit(g->scale1,"%");
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 100.0, 0.1, p->source_lightness_mix, 2));
dtgtk_slider_set_format_type(g->scale2,DARKTABLE_SLIDER_FORMAT_PERCENT);
dtgtk_slider_set_label(g->scale2,_("source mix"));
dtgtk_slider_set_unit(g->scale2,"%");
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("lightness of color"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("mix value of source lightness"), (char *)NULL);
g_signal_connect (G_OBJECT (g->gslider1), "value-changed",
G_CALLBACK (hue_callback), self);
g_signal_connect (G_OBJECT (g->gslider2), "value-changed",
G_CALLBACK (saturation_callback), self);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (lightness_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (source_lightness_mix_callback), self);
g_signal_connect (G_OBJECT (g->colorpick1), "clicked",
G_CALLBACK (colorpick_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_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(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)
{
dt_lib_image_t *d = (dt_lib_image_t *)malloc(sizeof(dt_lib_image_t));
self->data = (void *)d;
self->widget = gtk_vbox_new(TRUE, 5);
GtkBox *hbox;
GtkWidget *button;
hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
button = gtk_button_new_with_label(_("remove"));
d->remove_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("remove from the collection"), (char *)NULL);
gtk_box_pack_start(hbox, button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), (gpointer)0);
button = gtk_button_new_with_label(_("delete"));
d->delete_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("physically delete from disk"), (char *)NULL);
gtk_box_pack_start(hbox, button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), (gpointer)1);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
button = gtk_button_new_with_label(_("create hdr"));
d->create_hdr_button = button;
gtk_box_pack_start(hbox, button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), (gpointer)7);
g_object_set(G_OBJECT(button), "tooltip-text", _("create a high dynamic range image from selected shots"), (char *)NULL);
button = gtk_button_new_with_label(_("duplicate"));
d->duplicate_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("add a duplicate to the collection"), (char *)NULL);
gtk_box_pack_start(hbox, button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), (gpointer)3);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
GtkBox *hbox2 = GTK_BOX(gtk_hbox_new(TRUE, 5));
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, 0);
d->rotate_ccw_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("rotate selected images 90 degrees ccw"), (char *)NULL);
gtk_box_pack_start(hbox2, button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), (gpointer)4);
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, 1);
d->rotate_cw_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("rotate selected images 90 degrees cw"), (char *)NULL);
gtk_box_pack_start(hbox2, button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), (gpointer)5);
gtk_box_pack_start(hbox, GTK_WIDGET(hbox2), TRUE, TRUE, 0);
button = gtk_button_new_with_label(_("reset rotation"));
d->reset_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("reset rotation to exif data"), (char *)NULL);
gtk_box_pack_start(hbox, button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), (gpointer)6);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
}
void
gui_init (dt_imageio_module_storage_t *self)
{
self->gui_data = (dt_storage_flickr_gui_data_t *)g_malloc(sizeof(dt_storage_flickr_gui_data_t));
memset(self->gui_data,0,sizeof(dt_storage_flickr_gui_data_t));
dt_storage_flickr_gui_data_t *ui= self->gui_data;
self->widget = gtk_vbox_new(FALSE, 0);
GtkWidget *hbox1=gtk_hbox_new(FALSE,5);
GtkWidget *hbox0=gtk_hbox_new(FALSE,5);
GtkWidget *vbox1=gtk_vbox_new(FALSE,0);
GtkWidget *vbox2=gtk_vbox_new(FALSE,5);
ui->label1 = GTK_LABEL( gtk_label_new( _("flickr user") ) );
ui->label3 = GTK_LABEL( gtk_label_new( _("photosets") ) );
ui->labelPerms = GTK_LABEL( gtk_label_new( _("visible to") ) );
ui->label4 = GTK_LABEL( gtk_label_new( NULL ) );
set_status(ui,_("click login button to start"), "#ffffff");
ui->label5 = GTK_LABEL( gtk_label_new( _("title") ) );
ui->label6 = GTK_LABEL( gtk_label_new( _("summary") ) );
gtk_misc_set_alignment(GTK_MISC(ui->label1), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->labelPerms), 0.0, 0.9);
gtk_misc_set_alignment(GTK_MISC(ui->label3), 0.0, 0.7);
gtk_misc_set_alignment(GTK_MISC(ui->label5), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label6), 0.0, 0.5);
ui->entry1 = GTK_ENTRY( gtk_entry_new() );
ui->entry3 = GTK_ENTRY( gtk_entry_new() ); // Album title
ui->entry4 = GTK_ENTRY( gtk_entry_new() ); // Album summary
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry1));
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry3));
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry4));
/*
gtk_widget_add_events(GTK_WIDGET(ui->entry1), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry1), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry1), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry2), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry2), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry2), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry3), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry3), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry3), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry4), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry4), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry4), "focus-out-event", G_CALLBACK(focus_out), NULL);
*/
GHashTable* table = dt_pwstorage_get("flickr");
gchar* _username = g_strdup( g_hash_table_lookup(table, "username"));
g_hash_table_destroy(table);
gtk_entry_set_text( ui->entry1, _username == NULL?"":_username );
gtk_entry_set_text( ui->entry3, _("my new photoset") );
gtk_entry_set_text( ui->entry4, _("exported from darktable") );
GtkWidget *albumlist=gtk_hbox_new(FALSE,0);
ui->comboBox1 = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new()); // Available albums
dt_ellipsize_combo(GTK_COMBO_BOX(ui->comboBox1));
ui->dtbutton1 = DTGTK_BUTTON( dtgtk_button_new(dtgtk_cairo_paint_refresh,0) );
g_object_set(G_OBJECT(ui->dtbutton1), "tooltip-text", _("refresh album list"), (char *)NULL);
ui->button = GTK_BUTTON(gtk_button_new_with_label(_("login")));
g_object_set(G_OBJECT(ui->button), "tooltip-text", _("flickr login"), (char *)NULL);
gtk_widget_set_sensitive( GTK_WIDGET(ui->comboBox1), FALSE);
gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(ui->comboBox1), combobox_separator,ui->comboBox1,NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->dtbutton1), FALSE, FALSE, 0);
ui->checkButton2 = GTK_CHECK_BUTTON( gtk_check_button_new_with_label(_("export tags")) );
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON( ui->checkButton2 ),TRUE);
ui->permsComboBox = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new());
gtk_combo_box_text_append_text(ui->permsComboBox, _("you"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("friends"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("family"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("friends + family"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("everyone"));
gtk_combo_box_set_active(GTK_COMBO_BOX(ui->permsComboBox), 0); // Set default permission to private
gtk_box_pack_start(GTK_BOX(self->widget), hbox0, TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->label1 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->entry1 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->button ), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox1 ), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox1 ), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( gtk_label_new("")), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->labelPerms ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label3 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->label4 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->checkButton2 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->permsComboBox ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( albumlist ), TRUE, FALSE, 0);
// Create Album
ui->hbox1=GTK_BOX(gtk_hbox_new(FALSE,5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox1), TRUE);
vbox1=gtk_vbox_new(FALSE,0);
vbox2=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox1), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label5 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label6 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry3 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry4 ), TRUE, FALSE, 0);
// Setup signals
// add signal on realize and hide gtk_widget_hide(GTK_WIDGET(ui->hbox1));
g_signal_connect(G_OBJECT(ui->dtbutton1), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->entry1), "changed", G_CALLBACK(flickr_entry_changed), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox1), "changed", G_CALLBACK(flickr_album_changed), (gpointer)ui);
/**
dont' populate the combo on startup, save 3 second
// If username and password is stored, let's populate the combo
if( _username && _password )
{
ui->user_token = _password;
refresh_albums(ui);
}
*/
if( _username )
g_free (_username);
gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox1), 0);
}
void gui_init(dt_imageio_module_storage_t *self)
{
self->gui_data = (dt_storage_flickr_gui_data_t *)g_malloc0(sizeof(dt_storage_flickr_gui_data_t));
dt_storage_flickr_gui_data_t *ui = self->gui_data;
self->widget = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10));
int line = 0;
GHashTable *table = dt_pwstorage_get("flickr");
gchar *_username = g_strdup(g_hash_table_lookup(table, "username"));
g_hash_table_destroy(table);
GtkWidget *hbox, *label, *button;
label = gtk_label_new(_("flickr user"));
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
ui->user_entry = GTK_ENTRY(gtk_entry_new());
gtk_widget_set_hexpand(GTK_WIDGET(ui->user_entry), TRUE);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->user_entry));
gtk_entry_set_text(ui->user_entry, _username == NULL ? "" : _username);
g_signal_connect(G_OBJECT(ui->user_entry), "changed", G_CALLBACK(flickr_entry_changed), (gpointer)ui);
gtk_entry_set_width_chars(GTK_ENTRY(ui->user_entry), 0);
button = gtk_button_new_with_label(_("login"));
g_object_set(G_OBJECT(button), "tooltip-text", _("flickr login"), (char *)NULL);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->user_entry), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_grid_attach_next_to(GTK_GRID(self->widget), hbox, label, GTK_POS_RIGHT, 1, 1);
ui->status_label = GTK_LABEL(gtk_label_new(NULL));
gtk_widget_set_halign(GTK_WIDGET(ui->status_label), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(ui->status_label), 1, line++, 1, 1);
ui->export_tags = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->export_tags, NULL, _("export tags"));
dt_bauhaus_combobox_add(ui->export_tags, _("yes"));
dt_bauhaus_combobox_add(ui->export_tags, _("no"));
dt_bauhaus_combobox_set(ui->export_tags, 0);
gtk_widget_set_hexpand(ui->export_tags, TRUE);
gtk_grid_attach(GTK_GRID(self->widget), ui->export_tags, 0, line++, 2, 1);
ui->permission_list = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->permission_list, NULL, _("visible to"));
dt_bauhaus_combobox_add(ui->permission_list, _("you"));
dt_bauhaus_combobox_add(ui->permission_list, _("friends"));
dt_bauhaus_combobox_add(ui->permission_list, _("family"));
dt_bauhaus_combobox_add(ui->permission_list, _("friends + family"));
dt_bauhaus_combobox_add(ui->permission_list, _("everyone"));
dt_bauhaus_combobox_set(ui->permission_list, 0); // Set default permission to private
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(ui->permission_list), 0, line++, 2, 1);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5));
ui->album_list = dt_bauhaus_combobox_new(NULL); // Available albums
dt_bauhaus_widget_set_label(ui->album_list, NULL, _("photosets"));
g_signal_connect(G_OBJECT(ui->album_list), "value-changed", G_CALLBACK(flickr_album_changed), (gpointer)ui);
gtk_widget_set_sensitive(ui->album_list, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), ui->album_list, TRUE, TRUE, 0);
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_DO_NOT_USE_BORDER);
g_object_set(G_OBJECT(button), "tooltip-text", _("refresh album list"), (char *)NULL);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(self->widget), hbox, 0, line++, 2, 1);
// the box that gets shown when a new album is to be created
ui->create_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5)));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->create_box), TRUE);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(ui->create_box), 0, line++, 2, 1);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
label = gtk_label_new(_("title"));
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
ui->title_entry = GTK_ENTRY(gtk_entry_new()); // Album title
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->title_entry));
gtk_entry_set_text(ui->title_entry, _("my new photoset"));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->title_entry), TRUE, TRUE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(ui->title_entry), 0);
gtk_box_pack_start(ui->create_box, hbox, FALSE, FALSE, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
label = gtk_label_new(_("summary"));
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
ui->summary_entry = GTK_ENTRY(gtk_entry_new()); // Album summary
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->summary_entry));
gtk_entry_set_text(ui->summary_entry, _("exported from darktable"));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->summary_entry), TRUE, TRUE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(ui->summary_entry), 0);
gtk_box_pack_start(ui->create_box, hbox, TRUE, TRUE, 0);
set_status(ui, _("click login button to start"), "#ffffff");
/**
don't populate the combo on startup, save 3 second
// If username and password is stored, let's populate the combo
if( _username && _password )
{
ui->user_token = _password;
refresh_albums(ui);
}
*/
g_free(_username);
dt_bauhaus_combobox_set(ui->album_list, 0);
}
void
gui_init (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)
{
dt_lib_image_t *d = (dt_lib_image_t *)malloc(sizeof(dt_lib_image_t));
self->data = (void *)d;
self->widget = gtk_grid_new();
GtkGrid *grid = GTK_GRID(self->widget);
gtk_grid_set_row_spacing(grid, DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_spacing(grid, DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_homogeneous(grid, TRUE);
int line = 0;
GtkWidget *button;
button = gtk_button_new_with_label(_("remove"));
d->remove_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("remove from the collection"), (char *)NULL);
gtk_grid_attach(grid, button, 0, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(0));
button = gtk_button_new_with_label(_("delete"));
d->delete_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("physically delete from disk"), (char *)NULL);
gtk_grid_attach(grid, button, 2, line++, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(1));
button = gtk_button_new_with_label(_("move"));
d->move_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("move to other folder"), (char *)NULL);
gtk_grid_attach(grid, button, 0, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(8));
button = gtk_button_new_with_label(_("copy"));
d->copy_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("copy to other folder"), (char *)NULL);
gtk_grid_attach(grid, button, 2, line++, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(9));
button = gtk_button_new_with_label(_("create HDR"));
d->create_hdr_button = button;
gtk_grid_attach(grid, button, 0, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(7));
g_object_set(G_OBJECT(button), "tooltip-text", _("create a high dynamic range image from selected shots"),
(char *)NULL);
button = gtk_button_new_with_label(_("duplicate"));
d->duplicate_button = button;
g_object_set(G_OBJECT(button), "tooltip-text",
_("add a duplicate to the collection, including its history stack"), (char *)NULL);
gtk_grid_attach(grid, button, 2, line++, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(3));
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_DO_NOT_USE_BORDER);
d->rotate_ccw_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("rotate selected images 90 degrees CCW"), (char *)NULL);
gtk_grid_attach(grid, button, 0, line, 1, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(4));
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, 1 | CPF_DO_NOT_USE_BORDER);
d->rotate_cw_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("rotate selected images 90 degrees CW"), (char *)NULL);
gtk_grid_attach(grid, button, 1, line, 1, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(5));
button = gtk_button_new_with_label(_("reset rotation"));
d->reset_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("reset rotation to EXIF data"), (char *)NULL);
gtk_grid_attach(grid, button, 2, line++, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(6));
button = gtk_button_new_with_label(_("copy locally"));
d->cache_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("copy the image locally"), (char *)NULL);
gtk_grid_attach(grid, button, 0, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(12));
button = gtk_button_new_with_label(_("resync local copy"));
d->uncache_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("synchronize the image's XMP and remove the local copy"),
(char *)NULL);
gtk_grid_attach(grid, button, 2, line++, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(13));
button = gtk_button_new_with_label(_("group"));
d->group_button = button;
g_object_set(G_OBJECT(button), "tooltip-text",
_("add selected images to expanded group or create a new one"), (char *)NULL);
gtk_grid_attach(grid, button, 0, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(10));
button = gtk_button_new_with_label(_("ungroup"));
d->ungroup_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("remove selected images from the group"), (char *)NULL);
gtk_grid_attach(grid, button, 2, line, 2, 1);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_clicked), GINT_TO_POINTER(11));
}