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_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_connect (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);
}
static void _slider_init (GtkDarktableSlider *slider)
{
slider->is_dragging=FALSE;
slider->is_sensibility_key_pressed=FALSE;
slider->entry=gtk_entry_new();
gtk_widget_add_events (GTK_WIDGET (slider),
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK |
GDK_POINTER_MOTION_MASK);
GtkWidget *hbox=gtk_hbox_new(TRUE,0);
slider->hbox = GTK_HBOX(hbox);
GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, DTGTK_SLIDER_BORDER_WIDTH*2, DTGTK_SLIDER_ADJUST_BUTTON_WIDTH+DTGTK_SLIDER_BORDER_WIDTH*2);
gtk_container_add(GTK_CONTAINER(alignment), slider->entry);
gtk_box_pack_start(GTK_BOX(hbox),alignment,TRUE,TRUE,0);
gtk_container_add(GTK_CONTAINER(slider),hbox);
gtk_entry_set_has_frame (GTK_ENTRY(slider->entry), FALSE);
gtk_entry_set_alignment (GTK_ENTRY(slider->entry), 1.0);
g_signal_connect (G_OBJECT (slider->entry), "key-press-event", G_CALLBACK(_slider_entry_key_event), (gpointer)slider);
dt_gui_key_accel_block_on_focus_connect (slider->entry);
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_tool_lighttable_t *d = (dt_lib_tool_lighttable_t *)g_malloc0(sizeof(dt_lib_tool_lighttable_t));
self->data = (void *)d;
self->widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
d->layout = dt_conf_get_int("plugins/lighttable/layout");
d->previous_layout = d->layout == DT_LIGHTTABLE_LAYOUT_EXPOSE ? DT_LIGHTTABLE_LAYOUT_FILEMANAGER : DT_LIGHTTABLE_LAYOUT_EXPOSE;
d->current_zoom = dt_conf_get_int("plugins/lighttable/images_in_row");
/* create layout selection combobox */
d->layout_combo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(d->layout_combo), _("zoomable light table"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(d->layout_combo), _("file manager"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(d->layout_combo), _("expose"));
gtk_combo_box_set_active(GTK_COMBO_BOX(d->layout_combo), d->layout);
g_signal_connect(G_OBJECT(d->layout_combo), "changed", G_CALLBACK(_lib_lighttable_layout_changed), (gpointer)self);
gtk_box_pack_start(GTK_BOX(self->widget), d->layout_combo, TRUE, TRUE, 0);
/* create horizontal zoom slider */
d->zoom = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 1, 21, 1);
gtk_widget_set_size_request(GTK_WIDGET(d->zoom), DT_PIXEL_APPLY_DPI(140), -1);
gtk_scale_set_draw_value(GTK_SCALE(d->zoom), FALSE);
gtk_range_set_increments(GTK_RANGE(d->zoom), 1, 1);
gtk_box_pack_start(GTK_BOX(self->widget), d->zoom, TRUE, TRUE, 0);
/* manual entry of the zoom level */
d->zoom_entry = gtk_entry_new();
gtk_entry_set_alignment(GTK_ENTRY(d->zoom_entry), 1.0);
gtk_entry_set_max_length(GTK_ENTRY(d->zoom_entry), 2);
gtk_entry_set_width_chars(GTK_ENTRY(d->zoom_entry), 3);
gtk_entry_set_max_width_chars(GTK_ENTRY(d->zoom_entry), 3);
dt_gui_key_accel_block_on_focus_connect(d->zoom_entry);
gtk_box_pack_start(GTK_BOX(self->widget), d->zoom_entry, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(d->zoom), "value-changed", G_CALLBACK(_lib_lighttable_zoom_slider_changed),
(gpointer)self);
g_signal_connect(d->zoom_entry, "key-press-event", G_CALLBACK(_lib_lighttable_zoom_entry_changed), self);
gtk_range_set_value(GTK_RANGE(d->zoom), d->current_zoom);
_lib_lighttable_zoom_slider_changed(GTK_RANGE(d->zoom), self); // the slider defaults to 1 and GTK doesn't
// fire a value-changed signal when setting
// it to 1 => empty text box
gtk_widget_set_no_show_all(d->zoom, TRUE);
gtk_widget_set_no_show_all(d->zoom_entry, TRUE);
_lib_lighttable_layout_changed(GTK_COMBO_BOX(d->layout_combo), self);
darktable.view_manager->proxy.lighttable.module = self;
darktable.view_manager->proxy.lighttable.set_zoom = _lib_lighttable_set_zoom;
darktable.view_manager->proxy.lighttable.get_zoom = _lib_lighttable_get_zoom;
darktable.view_manager->proxy.lighttable.get_layout = _lib_lighttable_get_layout;
darktable.view_manager->proxy.lighttable.set_layout = _lib_lighttable_set_layout;
}
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);
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_tool_lighttable_t *d = (dt_lib_tool_lighttable_t *)g_malloc(sizeof(dt_lib_tool_lighttable_t));
self->data = (void *)d;
memset(d,0,sizeof(dt_lib_tool_lighttable_t));
self->widget = gtk_hbox_new(FALSE,2);
GtkWidget* widget;
/* create layout selection combobox */
widget = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(widget), _("zoomable light table"));
gtk_combo_box_append_text(GTK_COMBO_BOX(widget), _("file manager"));
gtk_combo_box_set_active(GTK_COMBO_BOX(widget), dt_conf_get_int("plugins/lighttable/layout"));
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (_lib_lighttable_layout_changed),
(gpointer)self);
gtk_box_pack_start(GTK_BOX(self->widget), widget, TRUE, TRUE, 0);
/* create horizontal zoom slider */
d->zoom = gtk_hscale_new_with_range(1, 26, 1);
gtk_widget_set_size_request (GTK_WIDGET(d->zoom), 160, -1);
gtk_scale_set_draw_value(GTK_SCALE(d->zoom), FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), d->zoom, TRUE, TRUE, 0);
/* manual entry of the zoom level */
d->zoom_entry = gtk_entry_new();
gtk_entry_set_alignment(GTK_ENTRY(d->zoom_entry), 1.0);
gtk_entry_set_max_length(GTK_ENTRY(d->zoom_entry), 2);
g_object_set(G_OBJECT(d->zoom_entry), "width-chars", 3, (char *)NULL);
dt_gui_key_accel_block_on_focus_connect(d->zoom_entry);
gtk_box_pack_start(GTK_BOX(self->widget), d->zoom_entry, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT(d->zoom), "value-changed",
G_CALLBACK (_lib_lighttable_zoom_slider_changed),
(gpointer)self);
g_signal_connect(d->zoom_entry, "key-press-event", G_CALLBACK(_lib_lighttable_zoom_entry_changed), self);
gtk_range_set_value(GTK_RANGE(d->zoom), dt_conf_get_int("plugins/lighttable/images_in_row"));
darktable.view_manager->proxy.lighttable.module = self;
darktable.view_manager->proxy.lighttable.set_zoom = _lib_lighttable_set_zoom;
}
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);
}
/*
http://nominatim.openstreetmap.org/search/norrköping?format=xml&limit=5
*/
void gui_init(dt_lib_module_t *self)
{
self->data = calloc(1, sizeof(dt_lib_location_t));
dt_lib_location_t *lib = self->data;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
/* add search box */
lib->search = GTK_ENTRY(gtk_entry_new());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(lib->search));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(lib->search), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(lib->search), "activate", G_CALLBACK(_lib_location_entry_activated),
(gpointer)self);
/* add result vbox */
lib->result = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(10));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(lib->result), TRUE, FALSE, DT_PIXEL_APPLY_DPI(2));
}
void
gui_init (dt_lib_module_t *self)
{
self->widget = gtk_vbox_new(TRUE, 5);
self->data = malloc(sizeof(dt_lib_session_t));
memset(self->data,0,sizeof(dt_lib_session_t));
// Setup lib data
dt_lib_session_t *lib=self->data;
// Setup gui
self->widget = gtk_vbox_new(FALSE, 5);
GtkBox *hbox, *vbox1, *vbox2;
// Session settings
hbox = GTK_BOX(gtk_hbox_new(FALSE, 5));
vbox1 = GTK_BOX(gtk_vbox_new(TRUE, 5));
vbox2 = GTK_BOX(gtk_vbox_new(TRUE, 5));
lib->gui.label1 = GTK_LABEL(gtk_label_new(_("jobcode")));
gtk_misc_set_alignment(GTK_MISC(lib->gui.label1 ), 0.0, 0.5);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label1), TRUE, TRUE, 0);
lib->gui.entry1 = GTK_ENTRY(gtk_entry_new());
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (lib->gui.entry1));
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.entry1), TRUE, TRUE, 0);
lib->gui.button1 = GTK_BUTTON(gtk_button_new_with_label( _("create") ));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox2), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(lib->gui.button1), TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (lib->gui.button1), "clicked",
G_CALLBACK (create_callback), self);
gchar *str = dt_conf_get_string("plugins/session/jobcode");
gtk_entry_set_text(lib->gui.entry1, str );
g_free(str);
}
void gui_init(dt_lib_module_t *self)
{
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
self->data = calloc(1, sizeof(dt_lib_session_t));
// Setup lib data
dt_lib_session_t *lib = self->data;
// Setup gui
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
GtkBox *hbox, *vbox1, *vbox2;
// Session settings
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
vbox1 = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5)));
vbox2 = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5)));
lib->gui.label1 = GTK_LABEL(gtk_label_new(_("jobcode")));
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label1), GTK_ALIGN_START);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label1), TRUE, TRUE, 0);
lib->gui.entry1 = GTK_ENTRY(gtk_entry_new());
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.entry1), 0);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(lib->gui.entry1));
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.entry1), TRUE, TRUE, 0);
lib->gui.button1 = GTK_BUTTON(gtk_button_new_with_label(_("create")));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox2), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(lib->gui.button1), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(lib->gui.button1), "clicked", G_CALLBACK(create_callback), self);
gchar *str = dt_conf_get_string("plugins/session/jobcode");
gtk_entry_set_text(lib->gui.entry1, str);
g_free(str);
}
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)
{
dt_lib_tagging_t *d = (dt_lib_tagging_t *)malloc(sizeof(dt_lib_tagging_t));
self->data = (void *)d;
d->imgsel = -1;
self->widget = gtk_vbox_new(TRUE, 5);
gtk_widget_set_size_request(self->widget,100,-1);
GtkBox *box, *hbox;
GtkWidget *button;
GtkWidget *w;
GtkListStore *liststore;
// left side, current
box = GTK_BOX(gtk_vbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0);
w = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(box, w, TRUE, TRUE, 0);
d->current = GTK_TREE_VIEW(gtk_tree_view_new());
gtk_tree_view_set_headers_visible(d->current, FALSE);
liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT);
GtkTreeViewColumn *col = gtk_tree_view_column_new();
gtk_tree_view_append_column(d->current, col);
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_TAGGING_COL_TAG);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->current),
GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(d->current, GTK_TREE_MODEL(liststore));
g_object_unref(liststore);
g_object_set(G_OBJECT(d->current), "tooltip-text", _("attached tags,\ndoubleclick to detach"), (char *)NULL);
g_signal_connect(G_OBJECT (d->current), "row-activated", G_CALLBACK (detach_activated), (gpointer)self);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->current));
// attach/detach buttons
hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
button = gtk_button_new_with_label(_("attach"));
d->attach_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("attach tag to all selected images"), (char *)NULL);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK (attach_button_clicked), (gpointer)self);
button = gtk_button_new_with_label(_("detach"));
d->detach_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("detach tag from all selected images"), (char *)NULL);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK (detach_button_clicked), (gpointer)self);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0);
// right side, related
box = GTK_BOX(gtk_vbox_new(FALSE, 5));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 5);
// text entry and new button
w = gtk_entry_new();
g_object_set(G_OBJECT(w), "tooltip-text", _("enter tag name"), (char *)NULL);
gtk_box_pack_start(box, w, TRUE, TRUE, 0);
gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK);
// g_signal_connect(G_OBJECT(w), "key-release-event",
g_signal_connect(G_OBJECT(w), "changed",
G_CALLBACK(tag_name_changed), (gpointer)self);
g_signal_connect(G_OBJECT (w), "activate",
G_CALLBACK (entry_activated), (gpointer)self);
d->entry = GTK_ENTRY(w);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry));
// related tree view
w = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(w,-1,100);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(box, w, TRUE, TRUE, 0);
d->related = GTK_TREE_VIEW(gtk_tree_view_new());
gtk_tree_view_set_headers_visible(d->related, FALSE);
liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT);
col = gtk_tree_view_column_new();
gtk_tree_view_append_column(d->related, col);
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_TAGGING_COL_TAG);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->related),
GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(d->related, GTK_TREE_MODEL(liststore));
g_object_unref(liststore);
g_object_set(G_OBJECT(d->related), "tooltip-text", _("related tags,\ndoubleclick to attach"), (char *)NULL);
g_signal_connect(G_OBJECT (d->related), "row-activated", G_CALLBACK (attach_activated), (gpointer)self);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->related));
// attach and delete buttons
hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
button = gtk_button_new_with_label(_("new"));
d->new_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("create a new tag with the\nname you entered"), (char *)NULL);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK (new_button_clicked), (gpointer)self);
button = gtk_button_new_with_label(_("delete"));
d->delete_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("delete selected tag"), (char *)NULL);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK (delete_button_clicked), (gpointer)self);
gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0);
// add entry completion
GtkEntryCompletion *completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(d->entry, completion);
/* connect to mouse over id */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_lib_tagging_redraw_callback), self);
dt_control_signal_connect(darktable.signals, DT_SIGNAL_TAG_CHANGED, G_CALLBACK(_lib_tagging_tags_changed_callback), self);
set_keyword(self, d);
}
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);
}
static void entry_init(lua_State* L)
{
lua_entry entry;
luaA_to(L,lua_entry,&entry,1);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(entry->widget));
}
void gui_init(dt_lib_module_t *self)
{
dt_lib_styles_t *d = (dt_lib_styles_t *)malloc(sizeof(dt_lib_styles_t));
self->data = (void *)d;
d->edit_button = NULL;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
GtkWidget *w;
GtkWidget *scrolled;
/* list */
d->list = GTK_TREE_VIEW(gtk_tree_view_new());
gtk_tree_view_set_headers_visible(d->list, FALSE);
GtkListStore *liststore = gtk_list_store_new(DT_STYLES_NUM_COLS, G_TYPE_STRING, G_TYPE_STRING);
GtkTreeViewColumn *col = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(d->list), col);
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_STYLES_COL_NAME);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(d->list)), GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(GTK_TREE_VIEW(d->list), GTK_TREE_MODEL(liststore));
g_object_unref(liststore);
g_object_set(G_OBJECT(d->list), "tooltip-text", _("available styles,\ndoubleclick to apply"), (char *)NULL);
g_signal_connect(d->list, "row-activated", G_CALLBACK(_styles_row_activated_callback), d);
/* filter entry */
w = gtk_entry_new();
d->entry = GTK_ENTRY(w);
g_object_set(G_OBJECT(w), "tooltip-text", _("enter style name"), (char *)NULL);
g_signal_connect(d->entry, "changed", G_CALLBACK(entry_callback), d);
g_signal_connect(d->entry, "activate", G_CALLBACK(entry_activated), d);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry));
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), DT_PIXEL_APPLY_DPI(150));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->entry), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(scrolled), TRUE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(d->list));
d->duplicate = gtk_check_button_new_with_label(_("create duplicate"));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->duplicate), TRUE, FALSE, 0);
g_signal_connect(d->duplicate, "toggled", G_CALLBACK(duplicate_callback), d);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->duplicate),
dt_conf_get_bool("ui_last/styles_create_duplicate"));
g_object_set(d->duplicate, "tooltip-text", _("creates a duplicate of the image before applying style"),
(char *)NULL);
GtkWidget *hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
GtkWidget *hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), hbox2, TRUE, FALSE, 0);
// create
GtkWidget *cbutton = gtk_button_new_with_label(_("create"));
g_signal_connect(G_OBJECT(cbutton), "clicked", G_CALLBACK(create_clicked), d);
g_object_set(G_OBJECT(cbutton), "tooltip-text", _("create styles from history stack of selected images"),
(char *)NULL);
gtk_box_pack_start(GTK_BOX(hbox1), cbutton, TRUE, TRUE, 0);
// edit
GtkWidget *widget = gtk_button_new_with_label(_("edit"));
d->edit_button = widget;
g_signal_connect(widget, "clicked", G_CALLBACK(edit_clicked), d);
g_object_set(widget, "tooltip-text", _("edit the selected style in list above"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0);
// delete
widget = gtk_button_new_with_label(_("delete"));
d->delete_button = widget;
g_signal_connect(widget, "clicked", G_CALLBACK(delete_clicked), d);
g_object_set(widget, "tooltip-text", _("deletes the selected style in list above"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0);
// import button
GtkWidget *importButton = gtk_button_new_with_label(C_("styles", "import"));
d->import_button = importButton;
g_object_set(importButton, "tooltip-text", _("import style from a style file"), (char *)NULL);
g_signal_connect(importButton, "clicked", G_CALLBACK(import_clicked), d);
gtk_box_pack_start(GTK_BOX(hbox2), importButton, TRUE, TRUE, 0);
// export button
GtkWidget *exportButton = gtk_button_new_with_label(_("export"));
d->export_button = exportButton;
g_object_set(exportButton, "tooltip-text", _("export the selected style into a style file"), (char *)NULL);
g_signal_connect(exportButton, "clicked", G_CALLBACK(export_clicked), d);
gtk_box_pack_start(GTK_BOX(hbox2), exportButton, TRUE, TRUE, 0);
// add entry completion
GtkEntryCompletion *completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->list)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(d->entry, completion);
/* update filtered list */
_gui_styles_update_view(d);
}
/* construct widget above */
void gui_init(struct dt_imageio_module_storage_t *self)
{
self->gui_data = g_malloc0(sizeof(dt_storage_facebook_gui_data_t));
dt_storage_facebook_gui_data_t *ui = self->gui_data;
ui->facebook_api = fb_api_init();
self->widget = gtk_vbox_new(FALSE, 0);
//create labels
ui->label_album_title = GTK_LABEL( gtk_label_new( _("title") ) );
ui->label_album_summary = GTK_LABEL( gtk_label_new( _("summary") ) );
ui->label_album_privacy = GTK_LABEL(gtk_label_new(_("privacy")));
ui->label_status = GTK_LABEL(gtk_label_new(NULL));
gtk_misc_set_alignment(GTK_MISC(ui->label_album_title), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label_album_summary), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label_album_privacy), 0.0, 0.5);
//create entries
GtkListStore *model_username = gtk_list_store_new (COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); //text, token, id
ui->comboBox_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username)));
GtkCellRenderer *p_cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, "text", 0, NULL);
ui->entry_album_title = GTK_ENTRY(gtk_entry_new());
ui->entry_album_summary = GTK_ENTRY(gtk_entry_new());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->comboBox_username));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_summary));
//retrieve saved accounts
ui_refresh_users(ui);
//////// album list /////////
GtkWidget *albumlist = gtk_hbox_new(FALSE, 0);
GtkListStore *model_album = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); //name, id
ui->comboBox_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album)));
p_cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, "text", 0, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(ui->comboBox_album), FALSE);
gtk_combo_box_set_row_separator_func(ui->comboBox_album,combobox_separator,ui->comboBox_album,NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox_album), TRUE, TRUE, 0);
ui->comboBox_privacy= GTK_COMBO_BOX(gtk_combo_box_text_new());
GtkListStore *list_store = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_INT);
GtkTreeIter iter;
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("only me"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_SELF, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_ALL_FRIENDS, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("public"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_EVERYONE, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends of friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS, -1);
gtk_combo_box_set_model(ui->comboBox_privacy, GTK_TREE_MODEL(list_store));
gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox_privacy), 1); // Set default permission to private
ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login")));
ui->connected = FALSE;
//pack the ui
////the auth box
GtkWidget *hbox_auth = gtk_hbox_new(FALSE,5);
GtkWidget *vbox_auth_labels=gtk_vbox_new(FALSE,0);
GtkWidget *vbox_auth_fields=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->comboBox_username), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2);
////the album creation box
ui->hbox_album = GTK_BOX(gtk_hbox_new(FALSE,5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); //hide it by default
GtkWidget *vbox_album_labels=gtk_vbox_new(FALSE,0);
GtkWidget *vbox_album_fields=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_summary), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_summary), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_privacy), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->comboBox_privacy), TRUE, FALSE, 0);
//connect buttons to signals
g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox_username), "changed", G_CALLBACK(ui_combo_username_changed), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui);
g_object_unref(model_username);
g_object_unref(model_album);
g_object_unref(list_store);
}
static void _lib_duplicate_init_callback(gpointer instance, dt_lib_module_t *self)
{
dt_lib_duplicate_t *d = (dt_lib_duplicate_t *)self->data;
d->imgid = 0;
gtk_container_foreach(GTK_CONTAINER(d->duplicate_box), (GtkCallback)gtk_widget_destroy, 0);
// retrieve all the versions of the image
sqlite3_stmt *stmt;
dt_develop_t *dev = darktable.develop;
int first_imgid = -1;
// we get a summarize of all versions of the image
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "SELECT i.version, i.id, m.value FROM images AS "
"i LEFT JOIN meta_data AS m ON m.id = i.id AND "
"m.key = ?3 WHERE film_id = ?1 AND filename = "
"?2 ORDER BY i.version",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, dev->image_storage.film_id);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, dev->image_storage.filename, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, DT_METADATA_XMP_DC_TITLE);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *dr = gtk_drawing_area_new();
const int imgid = sqlite3_column_int(stmt, 1);
// select original picture
if (first_imgid == -1) first_imgid = imgid;
gtk_widget_set_size_request (dr, 100, 100);
g_object_set_data (G_OBJECT (dr),"imgid",GINT_TO_POINTER(imgid));
gtk_widget_add_events(dr, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
g_signal_connect (G_OBJECT (dr), "draw", G_CALLBACK (_lib_duplicate_thumb_draw_callback), self);
if (imgid != dev->image_storage.id)
{
g_signal_connect(G_OBJECT(dr), "button-press-event", G_CALLBACK(_lib_duplicate_thumb_press_callback), self);
g_signal_connect(G_OBJECT(dr), "button-release-event", G_CALLBACK(_lib_duplicate_thumb_release_callback), self);
}
gchar chl[256];
gchar *path = (gchar *)sqlite3_column_text(stmt, 2);
g_snprintf(chl, sizeof(chl), "%d", sqlite3_column_int(stmt, 0));
GtkWidget *tb = gtk_entry_new();
if(path) gtk_entry_set_text(GTK_ENTRY(tb), path);
gtk_entry_set_width_chars(GTK_ENTRY(tb), 15);
g_object_set_data (G_OBJECT (tb),"imgid",GINT_TO_POINTER(imgid));
g_signal_connect(G_OBJECT(tb), "focus-out-event", G_CALLBACK(_lib_duplicate_caption_out_callback), self);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(tb));
GtkWidget *lb = gtk_label_new (g_strdup(chl));
GtkWidget *bt = dtgtk_button_new(dtgtk_cairo_paint_cancel, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
g_object_set_data(G_OBJECT(bt), "imgid", GINT_TO_POINTER(imgid));
gtk_widget_set_size_request(bt, DT_PIXEL_APPLY_DPI(13), DT_PIXEL_APPLY_DPI(13));
g_signal_connect(G_OBJECT(bt), "clicked", G_CALLBACK(_lib_duplicate_delete), self);
gtk_box_pack_start(GTK_BOX(hb), dr, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hb), tb, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hb), lb, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hb), bt, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(d->duplicate_box), hb, FALSE, FALSE, 0);
}
sqlite3_finalize (stmt);
switch(d->select)
{
case DT_DUPLICATE_SELECT_FIRST:
_do_select(first_imgid);
break;
case DT_DUPLICATE_SELECT_CURRENT:
_do_select(darktable.develop->image_storage.id);
break;
case DT_DUPLICATE_SELECT_NONE:
default:
break;
}
d->select = DT_DUPLICATE_SELECT_NONE;
gtk_widget_show_all(d->duplicate_box);
}
void gui_init(dt_lib_module_t *self)
{
self->data = calloc(1, sizeof(dt_lib_camera_t));
// Setup lib data
dt_lib_camera_t *lib = self->data;
lib->data.listener = calloc(1, sizeof(dt_camctl_listener_t));
lib->data.listener->data = lib;
lib->data.listener->camera_error = _camera_error_callback;
lib->data.listener->camera_property_value_changed = _camera_property_value_changed;
lib->data.listener->camera_property_accessibility_changed = _camera_property_accessibility_changed;
// Setup gui
lib->gui.rows = 0;
lib->gui.prop_end = 0;
self->widget = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
lib->gui.main_grid = GTK_GRID(self->widget);
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
GtkBox *hbox;
// Camera control
GtkWidget *label = dt_ui_section_label_new(_("camera control"));
gtk_grid_attach(GTK_GRID(self->widget), label, lib->gui.rows++, 0, 2, 1);
lib->gui.label1 = gtk_label_new(_("modes"));
lib->gui.label2 = gtk_label_new(_("timer (s)"));
lib->gui.label3 = gtk_label_new(_("count"));
lib->gui.label4 = gtk_label_new(_("brackets"));
lib->gui.label5 = gtk_label_new(_("bkt. steps"));
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label1), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label2), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label3), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label4), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label5), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label1), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label2), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label3), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label4), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label5), 0, lib->gui.rows++, 1, 1);
// capture modes buttons
lib->gui.tb1 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_timer, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
lib->gui.tb2 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_filmstrip, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
lib->gui.tb3 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_bracket, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb1), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb2), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb3), TRUE, TRUE, 0);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(hbox), GTK_WIDGET(lib->gui.label1), GTK_POS_RIGHT, 1, 1);
lib->gui.sb1 = gtk_spin_button_new_with_range(1, 60, 1);
lib->gui.sb2 = gtk_spin_button_new_with_range(1, 500, 1);
lib->gui.sb3 = gtk_spin_button_new_with_range(1, 5, 1);
lib->gui.sb4 = gtk_spin_button_new_with_range(1, 9, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb1), GTK_WIDGET(lib->gui.label2), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb2), GTK_WIDGET(lib->gui.label3), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb3), GTK_WIDGET(lib->gui.label4), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb4), GTK_WIDGET(lib->gui.label5), GTK_POS_RIGHT, 1, 1);
lib->gui.button1 = gtk_button_new_with_label(_("capture image(s)"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.button1), 0, lib->gui.rows++, 2, 1);
g_object_set(G_OBJECT(lib->gui.tb1), "tooltip-text", _("toggle delayed capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.tb2), "tooltip-text", _("toggle sequenced capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.tb3), "tooltip-text", _("toggle bracketed capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb1), "tooltip-text",
_("the count of seconds before actually doing a capture"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb2), "tooltip-text",
_("the amount of images to capture in a sequence,\nyou can use this in conjunction with "
"delayed mode to create stop-motion sequences."),
(char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb3), "tooltip-text",
_("the amount of brackets on each side of centered shoot, amount of images = (brackets*2)+1."),
(char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb4), "tooltip-text",
_("the amount of steps per bracket, steps is camera configurable and usually 3 steps per "
"stop\nwith other words, 3 steps is 1EV exposure step between brackets."),
(char *)NULL);
g_signal_connect(G_OBJECT(lib->gui.tb1), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb2), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb3), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.button1), "clicked", G_CALLBACK(_capture_button_clicked), lib);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb1), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb2), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb3), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb4), FALSE);
// Camera settings
label = dt_ui_section_label_new(_("properties"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 2, 1);
lib->gui.prop_start = lib->gui.rows -1;
lib->gui.prop_end = lib->gui.rows;
// user specified properties
label = dt_ui_section_label_new(_("additional properties"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 2, 1);
label = gtk_label_new(_("label"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
lib->gui.plabel = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.plabel), 0);
dt_gui_key_accel_block_on_focus_connect(lib->gui.plabel);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.plabel), GTK_WIDGET(label), GTK_POS_RIGHT, 1, 1);
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
label = gtk_label_new(_("property"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
GtkWidget *widget = gtk_button_new_with_label("O");
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_show_property_popupmenu_clicked), lib);
lib->gui.pname = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.pname), 0);
dt_gui_key_accel_block_on_focus_connect(lib->gui.pname);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.pname), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(widget), FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(hbox), GTK_WIDGET(label), GTK_POS_RIGHT, 1, 1);
widget = gtk_button_new_with_label(_("add user property"));
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_add_property_button_clicked), lib);
gtk_widget_show(widget);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(widget), 0, lib->gui.rows++, 2, 1);
}
void gui_init(dt_lib_module_t *self)
{
self->data = calloc(1, sizeof(dt_lib_camera_t));
// Setup lib data
dt_lib_camera_t *lib = self->data;
lib->data.listener = calloc(1, sizeof(dt_camctl_listener_t));
lib->data.listener->data = lib;
lib->data.listener->camera_error = _camera_error_callback;
lib->data.listener->camera_property_value_changed = _camera_property_value_changed;
lib->data.listener->camera_property_accessibility_changed = _camera_property_accessibility_changed;
// Setup gui
lib->gui.rows = 0;
lib->gui.prop_end = 0;
self->widget = gtk_grid_new();
lib->gui.main_grid = GTK_GRID(self->widget);
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
GtkBox *hbox/*, *vbox1, *vbox2*/;
// Camera control
GtkWidget *label = dt_ui_section_label_new(_("camera control"));
gtk_grid_attach(GTK_GRID(self->widget), label, lib->gui.rows++, 0, 2, 1);
lib->gui.label1 = gtk_label_new(_("modes"));
lib->gui.label2 = gtk_label_new(_("timer (s)"));
lib->gui.label3 = gtk_label_new(_("count"));
lib->gui.label4 = gtk_label_new(_("brackets"));
lib->gui.label5 = gtk_label_new(_("bkt. steps"));
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label1), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label2), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label3), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label4), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label5), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label1), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label2), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label3), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label4), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label5), 0, lib->gui.rows++, 1, 1);
// capture modes buttons
lib->gui.tb1 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_timer, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
lib->gui.tb2 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_filmstrip, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
lib->gui.tb3 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_bracket, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb1), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb2), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb3), TRUE, TRUE, 0);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(hbox), GTK_WIDGET(lib->gui.label1), GTK_POS_RIGHT, 1, 1);
lib->gui.sb1 = gtk_spin_button_new_with_range(1, 60, 1);
lib->gui.sb2 = gtk_spin_button_new_with_range(1, 500, 1);
lib->gui.sb3 = gtk_spin_button_new_with_range(1, 5, 1);
lib->gui.sb4 = gtk_spin_button_new_with_range(1, 9, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb1), GTK_WIDGET(lib->gui.label2), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb2), GTK_WIDGET(lib->gui.label3), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb3), GTK_WIDGET(lib->gui.label4), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb4), GTK_WIDGET(lib->gui.label5), GTK_POS_RIGHT, 1, 1);
lib->gui.button1 = gtk_button_new_with_label(_("capture image(s)"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.button1), 0, lib->gui.rows++, 2, 1);
g_object_set(G_OBJECT(lib->gui.tb1), "tooltip-text", _("toggle delayed capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.tb2), "tooltip-text", _("toggle sequenced capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.tb3), "tooltip-text", _("toggle bracketed capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb1), "tooltip-text",
_("the count of seconds before actually doing a capture"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb2), "tooltip-text",
_("the amount of images to capture in a sequence,\nyou can use this in conjunction with "
"delayed mode to create stop-motion sequences."),
(char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb3), "tooltip-text",
_("the amount of brackets on each side of centered shoot, amount of images = (brackets*2)+1."),
(char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb4), "tooltip-text",
_("the amount of steps per bracket, steps is camera configurable and usually 3 steps per "
"stop\nwith other words, 3 steps is 1EV exposure step between brackets."),
(char *)NULL);
g_signal_connect(G_OBJECT(lib->gui.tb1), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb2), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb3), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.button1), "clicked", G_CALLBACK(_capture_button_clicked), lib);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb1), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb2), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb3), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb4), FALSE);
// Camera settings
dt_lib_camera_property_t *prop;
label = dt_ui_section_label_new(_("properties"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 2, 1);
lib->gui.prop_end = lib->gui.rows;
if((prop = _lib_property_add_new(lib, _("program"), "expprogram")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("focus mode"), "focusmode")) != NULL)
_lib_property_add_to_gui(prop, lib);
else if((prop = _lib_property_add_new(lib, _("focus mode"), "drivemode")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("aperture"), "f-number")) != NULL)
_lib_property_add_to_gui(prop, lib);
else if((prop = _lib_property_add_new(lib, _("aperture"), "aperture")) != NULL) // for Canon cameras
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("focal length"), "focallength")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("shutterspeed2"), "shutterspeed2")) != NULL)
_lib_property_add_to_gui(prop, lib);
else if((prop = _lib_property_add_new(lib, _("shutterspeed"), "shutterspeed")) != NULL) // Canon, again
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("ISO"), "iso")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("WB"), "whitebalance")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("quality"), "imagequality")) != NULL)
_lib_property_add_to_gui(prop, lib);
if((prop = _lib_property_add_new(lib, _("size"), "imagesize")) != NULL)
_lib_property_add_to_gui(prop, lib);
/* add user widgets */
GSList *options = dt_conf_all_string_entries("plugins/capture/tethering/properties");
if(options)
{
GSList *item = options;
if(item)
{
do
{
dt_conf_string_entry_t *entry = (dt_conf_string_entry_t *)item->data;
/* get the label from key */
char *p = entry->key;
const char *end = entry->key + strlen(entry->key);
while(p++ < end)
if(*p == '_') *p = ' ';
if((prop = _lib_property_add_new(lib, entry->key, entry->value)) != NULL)
_lib_property_add_to_gui(prop, lib);
} while((item = g_slist_next(item)) != NULL);
}
}
/* build the propertymenu */
dt_camctl_camera_build_property_menu(darktable.camctl, NULL, &lib->gui.properties_menu,
G_CALLBACK(_property_choice_callback), lib);
// user specified properties
label = dt_ui_section_label_new(_("additional properties"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 2, 1);
label = gtk_label_new(_("label"));
lib->gui.plabel = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.plabel), 0);
dt_gui_key_accel_block_on_focus_connect(lib->gui.plabel);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.plabel), GTK_WIDGET(label), GTK_POS_RIGHT, 1, 1);
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
label = gtk_label_new(_("property"));
GtkWidget *widget = gtk_button_new_with_label("O");
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_show_property_popupmenu_clicked), lib);
lib->gui.pname = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.pname), 0);
dt_gui_key_accel_block_on_focus_connect(lib->gui.pname);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.pname), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(widget), FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(hbox), GTK_WIDGET(label), GTK_POS_RIGHT, 1, 1);
widget = gtk_button_new_with_label(_("add user property"));
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_add_property_button_clicked), lib);
gtk_widget_show(widget);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(widget), 0, lib->gui.rows++, 2, 1);
// Get camera model name
lib->data.camera_model = dt_camctl_camera_get_model(darktable.camctl, NULL);
// Register listener
dt_camctl_register_listener(darktable.camctl, lib->data.listener);
dt_camctl_tether_mode(darktable.camctl, NULL, TRUE);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_watermark_gui_data_t));
dt_iop_watermark_gui_data_t *g = (dt_iop_watermark_gui_data_t *)self->gui_data;
dt_iop_watermark_params_t *p = (dt_iop_watermark_params_t *)self->params;
int line = 0;
self->widget = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_BAUHAUS_SPACE);
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10));
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("content")), 0, line++, 3, 1);
// Add the marker combobox
gchar configdir[PATH_MAX] = { 0 };
gchar datadir[PATH_MAX] = { 0 };
dt_loc_get_datadir(datadir, sizeof(datadir));
dt_loc_get_user_config_dir(configdir, sizeof(configdir));
GtkWidget *label = dtgtk_reset_label_new(_("marker"), self, &p->filename, sizeof(p->filename));
g->watermarks = dt_bauhaus_combobox_new(self);
gtk_widget_set_hexpand(GTK_WIDGET(g->watermarks), TRUE);
char *tooltip = g_strdup_printf(_("SVG watermarks in %s/watermarks or %s/watermarks"), configdir, datadir);
gtk_widget_set_tooltip_text(g->watermarks, tooltip);
g_free(tooltip);
g->refresh = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->watermarks, label, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->refresh, g->watermarks, GTK_POS_RIGHT, 1, 1);
// Watermark color
float red = dt_conf_get_float("plugins/darkroom/watermark/color_red");
float green = dt_conf_get_float("plugins/darkroom/watermark/color_green");
float blue = dt_conf_get_float("plugins/darkroom/watermark/color_blue");
GdkRGBA color = (GdkRGBA){.red = red, .green = green, .blue = blue, .alpha = 1.0 };
label = dtgtk_reset_label_new(_("color"), self, &p->color, 3 * sizeof(float));
g->colorpick = gtk_color_button_new_with_rgba(&color);
gtk_widget_set_tooltip_text(g->colorpick, _("watermark color, tag:\n$(WATERMARK_COLOR)"));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select watermark color"));
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->colorpick, label, GTK_POS_RIGHT, 2, 1);
// Simple text
label = gtk_label_new(_("text"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
g->text = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(g->text), 1);
gtk_widget_set_tooltip_text(g->text, _("text string, tag:\n$(WATERMARK_TEXT)"));
dt_gui_key_accel_block_on_focus_connect(g->text);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->text, label, GTK_POS_RIGHT, 2, 1);
gchar *str = dt_conf_get_string("plugins/darkroom/watermark/text");
gtk_entry_set_text(GTK_ENTRY(g->text), str);
g_free(str);
// Text font
label = dtgtk_reset_label_new(_("font"), self, &p->font, sizeof(p->font));
str = dt_conf_get_string("plugins/darkroom/watermark/font");
g->fontsel = gtk_font_button_new_with_font(str==NULL?"DejaVu Sans 10":str);
GList *childs = gtk_container_get_children(GTK_CONTAINER(gtk_bin_get_child(GTK_BIN(g->fontsel))));
gtk_label_set_ellipsize(GTK_LABEL(childs->data), PANGO_ELLIPSIZE_MIDDLE);
g_list_free(childs);
gtk_widget_set_tooltip_text(g->fontsel, _("text font, tags:\n$(WATERMARK_FONT_FAMILY)\n"
"$(WATERMARK_FONT_STYLE)\n$(WATERMARK_FONT_WEIGHT)"));
gtk_font_button_set_show_size (GTK_FONT_BUTTON(g->fontsel), FALSE);
g_free(str);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->fontsel, label, GTK_POS_RIGHT, 2, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("properties")), 0, line++, 3, 1);
// Add opacity/scale sliders to table
g->opacity = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->opacity, 0);
dt_bauhaus_slider_set_format(g->opacity, "%.f%%");
dt_bauhaus_widget_set_label(g->opacity, NULL, _("opacity"));
g->scale = dt_bauhaus_slider_new_with_range(self, 1.0, 100.0, 1.0, p->scale, 0);
dt_bauhaus_slider_enable_soft_boundaries(g->scale, 1.0, 500.0);
dt_bauhaus_slider_set_format(g->scale, "%.f%%");
dt_bauhaus_widget_set_label(g->scale, NULL, _("scale"));
g->rotate = dt_bauhaus_slider_new_with_range(self, -180.0, 180.0, 1.0, p->rotate, 2);
dt_bauhaus_slider_set_format(g->rotate, "%.02f°");
dt_bauhaus_widget_set_label(g->rotate, NULL, _("rotation"));
gtk_grid_attach(GTK_GRID(self->widget), g->opacity, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->scale, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->rotate, 0, line++, 3, 1);
g->sizeto = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_add(g->sizeto, C_("size", "image"));
dt_bauhaus_combobox_add(g->sizeto, _("larger border"));
dt_bauhaus_combobox_add(g->sizeto, _("smaller border"));
dt_bauhaus_combobox_set(g->sizeto, p->sizeto);
dt_bauhaus_widget_set_label(g->sizeto, NULL, _("scale on"));
gtk_widget_set_tooltip_text(g->sizeto, _("size is relative to"));
gtk_grid_attach(GTK_GRID(self->widget), g->sizeto, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("position")), 0, line++, 3, 1);
// Create the 3x3 gtk table toggle button table...
label = dtgtk_reset_label_new(_("alignment"), self, &p->alignment, sizeof(p->alignment));
GtkWidget *bat = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
gtk_grid_set_column_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
for(int i = 0; i < 9; i++)
{
g->align[i] = dtgtk_togglebutton_new(dtgtk_cairo_paint_alignment, CPF_STYLE_FLAT | (CPF_SPECIAL_FLAG << i));
gtk_widget_set_size_request(GTK_WIDGET(g->align[i]), DT_PIXEL_APPLY_DPI(16), DT_PIXEL_APPLY_DPI(16));
gtk_grid_attach(GTK_GRID(bat), GTK_WIDGET(g->align[i]), i%3, i/3, 1, 1);
g_signal_connect(G_OBJECT(g->align[i]), "toggled", G_CALLBACK(alignment_callback), self);
}
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), bat, label, GTK_POS_RIGHT, 2, 1);
// x/y offset
g->x_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->xoffset, 3);
dt_bauhaus_slider_set_format(g->x_offset, "%.3f");
dt_bauhaus_widget_set_label(g->x_offset, NULL, _("x offset"));
g->y_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->yoffset, 3);
dt_bauhaus_slider_set_format(g->y_offset, "%.3f");
dt_bauhaus_widget_set_label(g->y_offset, NULL, _("y offset"));
gtk_grid_attach(GTK_GRID(self->widget), g->x_offset, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->y_offset, 0, line++, 3, 1);
// Let's add some tooltips and hook up some signals...
gtk_widget_set_tooltip_text(g->opacity, _("the opacity of the watermark"));
gtk_widget_set_tooltip_text(g->scale, _("the scale of the watermark"));
gtk_widget_set_tooltip_text(g->rotate, _("the rotation of the watermark"));
g_signal_connect(G_OBJECT(g->opacity), "value-changed", G_CALLBACK(opacity_callback), self);
g_signal_connect(G_OBJECT(g->scale), "value-changed", G_CALLBACK(scale_callback), self);
g_signal_connect(G_OBJECT(g->rotate), "value-changed", G_CALLBACK(rotate_callback), self);
g_signal_connect(G_OBJECT(g->x_offset), "value-changed", G_CALLBACK(xoffset_callback), self);
g_signal_connect(G_OBJECT(g->y_offset), "value-changed", G_CALLBACK(yoffset_callback), self);
g_signal_connect(G_OBJECT(g->refresh), "clicked", G_CALLBACK(refresh_callback), self);
refresh_watermarks(self);
g_signal_connect(G_OBJECT(g->watermarks), "value-changed", G_CALLBACK(watermark_callback), self);
g_signal_connect(G_OBJECT(g->sizeto), "value-changed", G_CALLBACK(sizeto_callback), self);
g_signal_connect(G_OBJECT(g->text), "changed", G_CALLBACK(text_callback), self);
g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self);
g_signal_connect(G_OBJECT(g->fontsel), "font-set", G_CALLBACK(fontsel_callback), self);
}
void gui_cleanup(struct dt_iop_module_t *self)
{
free(self->gui_data);
self->gui_data = NULL;
}
void gui_init(dt_lib_module_t *self)
{
GtkBox *hbox;
GtkWidget *button;
GtkWidget *label;
GtkEntryCompletion *completion;
int line = 0;
dt_lib_metadata_t *d = (dt_lib_metadata_t *)calloc(1, sizeof(dt_lib_metadata_t));
self->data = (void *)d;
d->imgsel = -1;
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));
g_signal_connect(self->widget, "draw", G_CALLBACK(draw), self);
struct
{
char *name;
GtkComboBox **box;
} entries[] = {
// clang-format off
{N_("title"), &d->title},
{N_("description"), &d->description},
{N_("creator"), &d->creator},
{N_("publisher"), &d->publisher},
{N_("rights"), &d->rights}
// clang-format on
};
for(line = 0; line < sizeof(entries) / sizeof(entries[0]); line++)
{
label = gtk_label_new(_(entries[line].name));
g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0);
GtkWidget *combobox = gtk_combo_box_text_new_with_entry();
*(entries[line].box) = GTK_COMBO_BOX(combobox);
gtk_widget_set_hexpand(combobox, TRUE);
GtkWidget *entry = gtk_bin_get_child(GTK_BIN(combobox));
dt_gui_key_accel_block_on_focus_connect(entry);
completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(combobox)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(GTK_ENTRY(entry), completion);
g_object_unref(completion);
g_signal_connect(entry, "key-press-event", G_CALLBACK(key_pressed), self);
gtk_entry_set_width_chars(GTK_ENTRY(entry), 0);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), combobox, label, GTK_POS_RIGHT, 1, 1);
}
// reset/apply buttons
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
button = gtk_button_new_with_label(_("clear"));
d->clear_button = button;
gtk_widget_set_hexpand(GTK_WIDGET(button), TRUE);
gtk_widget_set_tooltip_text(button, _("remove metadata from selected images"));
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(clear_button_clicked), (gpointer)self);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
button = gtk_button_new_with_label(_("apply"));
d->apply_button = button;
gtk_widget_set_hexpand(GTK_WIDGET(button), TRUE);
gtk_widget_set_tooltip_text(button, _("write metadata for selected images"));
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(apply_button_clicked), (gpointer)self);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
gtk_widget_set_margin_top(GTK_WIDGET(hbox), DT_PIXEL_APPLY_DPI(5));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(hbox), 0, line, 2, 1);
/* lets signup for mouse over image change signals */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE,
G_CALLBACK(_mouse_over_image_callback), self);
}
/* construct widget above */
void gui_init(struct dt_imageio_module_storage_t *self)
{
self->gui_data = g_malloc0(sizeof(dt_storage_gphoto_gui_data_t));
dt_storage_gphoto_gui_data_t *ui = self->gui_data;
ui->gphoto_api = gphoto_api_init();
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
// create labels
ui->label_album_title = GTK_LABEL(gtk_label_new(_("title")));
ui->label_status = GTK_LABEL(gtk_label_new(NULL));
gtk_widget_set_halign(GTK_WIDGET(ui->label_album_title), GTK_ALIGN_START);
// create entries
GtkListStore *model_username
= gtk_list_store_new(COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING); // text, token, refresh_token, id
ui->combo_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username)));
GtkCellRenderer *p_cell = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(p_cell), "ellipsize", PANGO_ELLIPSIZE_MIDDLE, "ellipsize-set", TRUE, "width-chars", 35,
(gchar *)0);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->combo_username), p_cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->combo_username), p_cell, "text", 0, NULL);
ui->entry_album_title = GTK_ENTRY(gtk_entry_new());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->combo_username));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title));
// retrieve saved accounts
ui_refresh_users(ui);
//////// album list /////////
GtkWidget *albumlist = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkListStore *model_album
= gtk_list_store_new(COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); // name, id
ui->combo_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album)));
p_cell = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(p_cell), "ellipsize", PANGO_ELLIPSIZE_MIDDLE, "ellipsize-set", TRUE, "width-chars", 35,
(gchar *)0);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->combo_album), p_cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->combo_album), p_cell, "text", 0, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(ui->combo_album), FALSE);
gtk_combo_box_set_row_separator_func(ui->combo_album, combobox_separator, ui->combo_album, NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->combo_album), TRUE, TRUE, 0);
ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login")));
ui->connected = FALSE;
// pack the ui
////the auth box
GtkWidget *hbox_auth = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
GtkWidget *vbox_auth_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *vbox_auth_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->combo_username), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2);
////the album creation box
ui->hbox_album = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); // hide it by default
GtkWidget *vbox_album_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *vbox_album_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0);
// connect buttons to signals
g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->combo_username), "changed", G_CALLBACK(ui_combo_username_changed),
(gpointer)ui);
g_signal_connect(G_OBJECT(ui->combo_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui);
g_object_unref(model_username);
g_object_unref(model_album);
}
void gui_init(dt_lib_module_t *self)
{
GtkBox *hbox;
GtkWidget *button;
GtkWidget *label;
GtkEntryCompletion *completion;
dt_lib_metadata_t *d = (dt_lib_metadata_t *)calloc(1, sizeof(dt_lib_metadata_t));
self->data = (void *)d;
d->imgsel = -1;
self->widget = gtk_table_new(6, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(self->widget), 5);
g_signal_connect(self->widget, "expose-event", G_CALLBACK(expose), self);
label = gtk_label_new(_("title"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 0, 1, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->title = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->title))));
completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->title)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->title))), completion);
g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->title))), "key-press-event", G_CALLBACK (key_pressed), self);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->title), 1, 2, 0, 1, GTK_EXPAND|GTK_FILL, 0, 0, 0);
label = gtk_label_new(_("description"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->description = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->description))));
completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->description)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->description))), completion);
g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->description))), "key-press-event", G_CALLBACK (key_pressed), self);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->description), 1, 2, 1, 2, GTK_EXPAND|GTK_FILL, 0, 0, 0);
label = gtk_label_new(_("creator"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 2, 3, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->creator = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->creator))));
completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->creator)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->creator))), completion);
g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->creator))), "key-press-event", G_CALLBACK (key_pressed), self);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->creator), 1, 2, 2, 3, GTK_EXPAND|GTK_FILL, 0, 0, 0);
label = gtk_label_new(_("publisher"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 3, 4, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->publisher = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->publisher))));
completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->publisher)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->publisher))), completion);
g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->publisher))), "key-press-event", G_CALLBACK (key_pressed), self);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->publisher), 1, 2, 3, 4, GTK_EXPAND|GTK_FILL, 0, 0, 0);
label = gtk_label_new(_("rights"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 4, 5, GTK_EXPAND|GTK_FILL, 0, 0, 0);
d->rights = GTK_COMBO_BOX(gtk_combo_box_text_new_with_entry());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->rights))));
completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(d->rights)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(d->rights))), completion);
g_signal_connect (GTK_WIDGET(gtk_bin_get_child(GTK_BIN(d->rights))), "key-press-event", G_CALLBACK (key_pressed), self);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->rights), 1, 2, 4, 5, GTK_EXPAND|GTK_FILL, 0, 0, 0);
g_object_unref(completion);
// reset/apply buttons
hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
button = gtk_button_new_with_label(_("clear"));
d->clear_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("remove metadata from selected images"), (char *)NULL);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK (clear_button_clicked), (gpointer)self);
button = gtk_button_new_with_label(_("apply"));
d->apply_button = button;
g_object_set(G_OBJECT(button), "tooltip-text", _("write metadata for selected images"), (char *)NULL);
g_signal_connect(G_OBJECT (button), "clicked",
G_CALLBACK (apply_button_clicked), (gpointer)self);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(hbox), 0, 2, 5, 6, GTK_EXPAND|GTK_FILL, 0, 0, 0);
/* lets signup for mouse over image change signals */
dt_control_signal_connect(darktable.signals,DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE,
G_CALLBACK(_mouse_over_image_callback), 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(dt_imageio_module_storage_t *self)
{
self->gui_data = (dt_storage_piwigo_gui_data_t *)g_malloc0(sizeof(dt_storage_piwigo_gui_data_t));
dt_storage_piwigo_gui_data_t *ui = self->gui_data;
ui->albums = NULL;
ui->accounts = NULL;
ui->api = NULL;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(8));
_piwigo_load_account(ui);
gchar *server = dt_conf_get_string("plugins/imageio/storage/export/piwigo/server");
// look for last server information
_piwigo_account_t *last_account = _piwigo_get_account(ui, server);
GtkWidget *hbox, *label, *button;
// account
ui->account_list = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->account_list, NULL, _("accounts"));
GList *a = ui->accounts;
int account_index = -1, index=0;
while(a)
{
_piwigo_account_t *account = (_piwigo_account_t *)a->data;
dt_bauhaus_combobox_add(ui->account_list, account->server);
if(!strcmp(account->server, server)) account_index = index;
index++;
a = g_list_next(a);
}
gtk_widget_set_hexpand(ui->account_list, TRUE);
g_signal_connect(G_OBJECT(ui->account_list), "value-changed", G_CALLBACK(_piwigo_account_changed), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(self->widget), ui->account_list, FALSE, FALSE, 0);
// server
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
label = gtk_label_new(_("server"));
g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0);
ui->server_entry = GTK_ENTRY(gtk_entry_new());
gtk_widget_set_tooltip_text(GTK_WIDGET(ui->server_entry),
_("the server name\ndefault protocol is https\nspecify http:// if non secure server"));
gtk_widget_set_hexpand(GTK_WIDGET(ui->server_entry), TRUE);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->server_entry));
gtk_entry_set_text(ui->server_entry, last_account?last_account->server:"piwigo.com");
g_signal_connect(G_OBJECT(ui->server_entry), "changed", G_CALLBACK(_piwigo_server_entry_changed), (gpointer)ui);
gtk_entry_set_width_chars(GTK_ENTRY(ui->server_entry), 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(label), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->server_entry), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_free(server);
// login
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
label = gtk_label_new(_("user"));
g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0);
ui->user_entry = GTK_ENTRY(gtk_entry_new());
gtk_widget_set_hexpand(GTK_WIDGET(ui->user_entry), TRUE);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->user_entry));
gtk_entry_set_text(ui->user_entry, last_account?last_account->username:"");
g_signal_connect(G_OBJECT(ui->user_entry), "changed", G_CALLBACK(_piwigo_entry_changed), (gpointer)ui);
gtk_entry_set_width_chars(GTK_ENTRY(ui->user_entry), 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(label), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->user_entry), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
// password
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
label = gtk_label_new(_("password"));
g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0);
ui->pwd_entry = GTK_ENTRY(gtk_entry_new());
gtk_entry_set_visibility(GTK_ENTRY(ui->pwd_entry), FALSE);
gtk_widget_set_hexpand(GTK_WIDGET(ui->pwd_entry), TRUE);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->pwd_entry));
gtk_entry_set_text(ui->pwd_entry, last_account?last_account->password:"");
g_signal_connect(G_OBJECT(ui->pwd_entry), "changed", G_CALLBACK(_piwigo_entry_changed), (gpointer)ui);
gtk_entry_set_width_chars(GTK_ENTRY(ui->pwd_entry), 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(label), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->pwd_entry), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
// login button
button = gtk_button_new_with_label(_("login"));
gtk_widget_set_tooltip_text(button, _("piwigo login"));
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_piwigo_login_clicked), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(self->widget), button, FALSE, FALSE, 0);
// status area
ui->status_label = GTK_LABEL(gtk_label_new(NULL));
gtk_widget_set_halign(GTK_WIDGET(ui->status_label), GTK_ALIGN_START);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->status_label), FALSE, FALSE, 0);
ui->export_tags = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->export_tags, NULL, _("export tags"));
dt_bauhaus_combobox_add(ui->export_tags, _("yes"));
dt_bauhaus_combobox_add(ui->export_tags, _("no"));
dt_bauhaus_combobox_set(ui->export_tags, 0);
gtk_widget_set_hexpand(ui->export_tags, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), ui->export_tags, FALSE, FALSE, 0);
// select account
if(account_index != -1) dt_bauhaus_combobox_set(ui->account_list, account_index);
// permissions list
ui->permission_list = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->permission_list, NULL, _("visible to"));
dt_bauhaus_combobox_add(ui->permission_list, _("everyone"));
dt_bauhaus_combobox_add(ui->permission_list, _("contacts"));
dt_bauhaus_combobox_add(ui->permission_list, _("friends"));
dt_bauhaus_combobox_add(ui->permission_list, _("family"));
dt_bauhaus_combobox_add(ui->permission_list, _("you"));
dt_bauhaus_combobox_set(ui->permission_list, 0); // Set default permission to private
gtk_box_pack_start(GTK_BOX(self->widget), ui->permission_list, FALSE, FALSE, 0);
// album list
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5));
ui->album_list = dt_bauhaus_combobox_new(NULL); // Available albums
dt_bauhaus_widget_set_label(ui->album_list, NULL, _("albums"));
g_signal_connect(G_OBJECT(ui->album_list), "value-changed", G_CALLBACK(_piwigo_album_changed), (gpointer)ui);
gtk_widget_set_sensitive(ui->album_list, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), ui->album_list, TRUE, TRUE, 0);
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_DO_NOT_USE_BORDER, NULL);
gtk_widget_set_tooltip_text(button, _("refresh album list"));
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_piwigo_refresh_clicked), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), hbox, FALSE, FALSE, 0);
// new album
ui->create_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5)));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->create_box), TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->create_box), FALSE, FALSE, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
label = gtk_label_new(_("title"));
g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
ui->new_album_entry = GTK_ENTRY(gtk_entry_new()); // Album title
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->new_album_entry));
gtk_entry_set_text(ui->new_album_entry, _("new album"));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->new_album_entry), TRUE, TRUE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(ui->new_album_entry), 0);
gtk_box_pack_start(ui->create_box, hbox, FALSE, FALSE, 0);
// parent album list
ui->parent_album_list = dt_bauhaus_combobox_new(NULL); // Available albums
dt_bauhaus_widget_set_label(ui->parent_album_list, NULL, _("parent album"));
gtk_widget_set_sensitive(ui->parent_album_list, TRUE);
gtk_box_pack_start(ui->create_box, ui->parent_album_list, TRUE, TRUE, 0);
_piwigo_set_status(ui, _("click login button to start"), "#ffffff");
}
