void enter(dt_view_t *self)
{
dt_capture_t *lib = (dt_capture_t *)self->data;
/* connect signal for mipmap update for a redraw */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_MIPMAP_UPDATED,
G_CALLBACK(_capture_mipmaps_updated_signal_callback), (gpointer)self);
/* connect signal for fimlstrip image activate */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_VIEWMANAGER_FILMSTRIP_ACTIVATE,
G_CALLBACK(_view_capture_filmstrip_activate_callback), self);
dt_view_filmstrip_scroll_to_image(darktable.view_manager, lib->image_id, TRUE);
/* initialize a session */
lib->session = dt_import_session_new();
char *tmp = dt_conf_get_string("plugins/capture/jobcode");
if(tmp != NULL)
{
_capture_view_set_jobcode(self, tmp);
g_free(tmp);
}
// register listener
lib->listener = g_malloc0(sizeof(dt_camctl_listener_t));
lib->listener->data = lib;
lib->listener->image_downloaded = _camera_capture_image_downloaded;
lib->listener->request_image_path = _camera_request_image_path;
lib->listener->request_image_filename = _camera_request_image_filename;
dt_camctl_register_listener(darktable.camctl, lib->listener);
}
static int32_t dt_camera_import_job_run(dt_job_t *job)
{
dt_camera_import_t *params = dt_control_job_get_params(job);
dt_control_log(_("starting to import images from camera"));
if(!dt_import_session_ready(params->shared.session))
{
dt_control_log("Failed to import images from camera.");
return 1;
}
guint total = g_list_length(params->images);
char message[512] = { 0 };
snprintf(message, sizeof(message),
ngettext("importing %d image from camera", "importing %d images from camera", total), total);
dt_control_job_set_progress_message(job, message);
// Switch to new filmroll
dt_film_open(dt_import_session_film_id(params->shared.session));
dt_ctl_switch_mode_to(DT_LIBRARY);
// register listener
dt_camctl_listener_t listener = { 0 };
listener.data = params;
listener.image_downloaded = _camera_import_image_downloaded;
listener.request_image_path = _camera_request_image_path;
listener.request_image_filename = _camera_request_image_filename;
// start download of images
dt_camctl_register_listener(darktable.camctl, &listener);
dt_camctl_import(darktable.camctl, params->camera, params->images);
dt_camctl_unregister_listener(darktable.camctl, &listener);
return 0;
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_import_t *d = (dt_lib_import_t *)g_malloc0(sizeof(dt_lib_import_t));
self->data = (void *)d;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
/* add import single image buttons */
GtkWidget *widget = gtk_button_new_with_label(_("image"));
d->import_file = GTK_BUTTON(widget);
gtk_widget_set_halign(gtk_bin_get_child(GTK_BIN(widget)), GTK_ALIGN_START);
gtk_widget_set_tooltip_text(widget, _("select one or more images to import"));
gtk_widget_set_can_focus(widget, TRUE);
gtk_widget_set_receives_default(widget, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), widget, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_lib_import_single_image_callback), self);
/* adding the import folder button */
widget = gtk_button_new_with_label(_("folder"));
d->import_directory = GTK_BUTTON(widget);
gtk_widget_set_halign(gtk_bin_get_child(GTK_BIN(widget)), GTK_ALIGN_START);
gtk_widget_set_tooltip_text(widget, _("select a folder to import as film roll"));
gtk_widget_set_can_focus(widget, TRUE);
gtk_widget_set_receives_default(widget, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), widget, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_lib_import_folder_callback), self);
#ifdef HAVE_GPHOTO2
/* add the rescan button */
GtkButton *scan = GTK_BUTTON(gtk_button_new_with_label(_("scan for devices")));
d->scan_devices = scan;
gtk_widget_set_halign(gtk_bin_get_child(GTK_BIN(scan)), GTK_ALIGN_START);
gtk_widget_set_tooltip_text(GTK_WIDGET(scan), _("scan for newly attached devices"));
g_signal_connect(G_OBJECT(scan), "clicked", G_CALLBACK(_lib_import_scan_devices_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(scan), TRUE, TRUE, 0);
/* add devices container for cameras */
d->devices = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->devices), FALSE, FALSE, 0);
_lib_import_ui_devices_update(self);
/* initialize camctl listener and update devices */
d->camctl_listener.data = self;
d->camctl_listener.control_status = _camctl_camera_control_status_callback;
d->camctl_listener.camera_disconnected = _camctl_camera_disconnected_callback;
dt_camctl_register_listener(darktable.camctl, &d->camctl_listener);
dt_control_signal_connect(darktable.signals, DT_SIGNAL_CAMERA_DETECTED, G_CALLBACK(_camera_detected),
self);
#endif
#ifdef USE_LUA
/* initialize the lua area and make sure it survives its parent's destruction*/
d->extra_lua_widgets = gtk_box_new(GTK_ORIENTATION_VERTICAL,5);
g_object_ref_sink(d->extra_lua_widgets);
#endif
}
static int32_t dt_camera_get_previews_job_run(dt_job_t *job)
{
dt_camera_get_previews_t *params = dt_control_job_get_params(job);
dt_camctl_register_listener(darktable.camctl, params->listener);
dt_camctl_get_previews(darktable.camctl, params->flags, params->camera);
dt_camctl_unregister_listener(darktable.camctl, params->listener);
return 0;
}
int32_t dt_camera_get_previews_job_run(dt_job_t *job)
{
dt_camera_get_previews_t *t=(dt_camera_get_previews_t*)job->param;
dt_camctl_register_listener(darktable.camctl,t->listener);
dt_camctl_get_previews(darktable.camctl,t->flags,t->camera);
dt_camctl_unregister_listener(darktable.camctl,t->listener);
g_free(t->listener);
return 0;
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_import_t *d = (dt_lib_import_t *)g_malloc(sizeof(dt_lib_import_t));
memset(d,0,sizeof(dt_lib_import_t));
self->data = (void *)d;
self->widget = gtk_vbox_new(FALSE, 5);
/* add import singel image buttons */
GtkWidget *widget = gtk_button_new_with_label(_("image"));
d->import_file = GTK_BUTTON(widget);
gtk_button_set_alignment(GTK_BUTTON(widget), 0.05, 5);
gtk_widget_set_tooltip_text(widget, _("select one or more images to import"));
gtk_widget_set_can_focus(widget, TRUE);
gtk_widget_set_receives_default(widget, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), widget, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (widget), "clicked",
G_CALLBACK (_lib_import_single_image_callback),
self);
/* adding the import folder button */
widget = gtk_button_new_with_label(_("folder"));
d->import_directory = GTK_BUTTON(widget);
gtk_button_set_alignment(GTK_BUTTON(widget), 0.05, 5);
gtk_widget_set_tooltip_text(widget,
_("select a folder to import as film roll"));
gtk_widget_set_can_focus(widget, TRUE);
gtk_widget_set_receives_default(widget, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "clicked",
G_CALLBACK (_lib_import_folder_callback),
self);
#ifdef HAVE_GPHOTO2
/* add devices container for cameras */
d->devices = GTK_BOX(gtk_vbox_new(FALSE,5));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->devices), FALSE, FALSE, 0);
/* initialize camctl listener and update devices */
d->camctl_listener.data = self;
d->camctl_listener.control_status = _camctl_camera_control_status_callback;
d->camctl_listener.camera_disconnected = _camctl_camera_disconnected_callback;
dt_camctl_register_listener(darktable.camctl, &d->camctl_listener );
_lib_import_ui_devices_update(self);
#endif
}
int32_t dt_camera_import_job_run(dt_job_t *job)
{
dt_camera_import_t *t = (dt_camera_import_t *)job->param;
dt_control_log(_("starting to import images from camera"));
if (!dt_import_session_ready(t->shared.session))
{
dt_control_log("Failed to import images from camera.");
return 1;
}
int total = g_list_length( t->images );
char message[512]= {0};
sprintf(message, ngettext ("importing %d image from camera", "importing %d images from camera", total), total );
t->bgj = dt_control_backgroundjobs_create(darktable.control, 0, message);
// Switch to new filmroll
dt_film_open(dt_import_session_film_id(t->shared.session));
dt_ctl_switch_mode_to(DT_LIBRARY);
// register listener
dt_camctl_listener_t listener= {0};
listener.data=t;
listener.image_downloaded=_camera_import_image_downloaded;
listener.request_image_path=_camera_request_image_path;
listener.request_image_filename=_camera_request_image_filename;
// start download of images
dt_camctl_register_listener(darktable.camctl,&listener);
dt_camctl_import(darktable.camctl,t->camera,t->images);
dt_camctl_unregister_listener(darktable.camctl,&listener);
dt_control_backgroundjobs_destroy(darktable.control, t->bgj);
dt_import_session_destroy(t->shared.session);
return 0;
}
void view_enter(struct dt_lib_module_t *self,struct dt_view_t *old_view,struct dt_view_t *new_view)
{
dt_lib_camera_t *lib = self->data;
/* add all camera properties to the widget */
dt_lib_camera_property_t *prop;
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);
}
g_slist_free_full(options, dt_conf_string_entry_free);
}
/* build the propertymenu we do it now because it needs an actual camera */
dt_camctl_camera_build_property_menu(darktable.camctl, NULL, &lib->gui.properties_menu,
G_CALLBACK(_property_choice_callback), lib);
// Register listener
dt_camctl_register_listener(darktable.camctl, lib->data.listener);
dt_camctl_tether_mode(darktable.camctl, NULL, TRUE);
// Get camera model name
lib->data.camera_model = dt_camctl_camera_get_model(darktable.camctl, NULL);
}
void
gui_init (dt_lib_module_t *self)
{
self->widget = gtk_vbox_new(FALSE, 5);
self->data = malloc(sizeof(dt_lib_camera_t));
memset(self->data,0,sizeof(dt_lib_camera_t));
// Setup lib data
dt_lib_camera_t *lib=self->data;
lib->data.listener = malloc(sizeof(dt_camctl_listener_t));
memset(lib->data.listener,0,sizeof(dt_camctl_listener_t));
lib->data.listener->data=lib;
lib->data.listener->camera_error=_camera_error_callback;
lib->data.listener->image_downloaded=_camera_tethered_downloaded_callback;
lib->data.listener->camera_property_value_changed=_camera_property_value_changed;
lib->data.listener->camera_property_accessibility_changed=_camera_property_accessibility_changed;
lib->data.listener->request_image_path=_camera_tethered_request_image_path;
lib->data.listener->request_image_filename=_camera_tethered_request_image_filename;
// Setup gui
self->widget = gtk_vbox_new(FALSE, 5);
GtkBox *hbox, *vbox1, *vbox2;
// Camera control
gtk_box_pack_start(GTK_BOX(self->widget), dtgtk_label_new(_("camera control"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT), TRUE, TRUE, 5);
vbox1 = GTK_BOX(gtk_vbox_new(TRUE, 0));
vbox2 = GTK_BOX(gtk_vbox_new(TRUE, 0));
lib->gui.label1=gtk_label_new(_("modes"));
lib->gui.label2=gtk_label_new(_("timer (s)"));
lib->gui.label3=gtk_label_new(_("count"));
lib->gui.label4=gtk_label_new(_("brackets"));
lib->gui.label5=gtk_label_new(_("bkt. steps"));
gtk_misc_set_alignment(GTK_MISC(lib->gui.label1 ), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(lib->gui.label2 ), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(lib->gui.label3 ), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(lib->gui.label4 ), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(lib->gui.label5 ), 0.0, 0.5);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label1), FALSE, FALSE, 0);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label2), FALSE, FALSE, 0);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label3), FALSE, FALSE, 0);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label4), FALSE, FALSE, 0);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label5), FALSE, FALSE, 0);
// capture modes buttons
lib->gui.tb1=DTGTK_TOGGLEBUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_timer,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
lib->gui.tb2=DTGTK_TOGGLEBUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_filmstrip,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
lib->gui.tb3=DTGTK_TOGGLEBUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_bracket,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb1), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb2), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb3), TRUE, TRUE, 0);
gtk_box_pack_start(vbox2, GTK_WIDGET(hbox),FALSE, FALSE, 0);
lib->gui.sb1=gtk_spin_button_new_with_range(1,60,1);
lib->gui.sb2=gtk_spin_button_new_with_range(1,500,1);
lib->gui.sb3=gtk_spin_button_new_with_range(1,5,1);
lib->gui.sb4=gtk_spin_button_new_with_range(1,9,1);
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.sb1), TRUE, TRUE, 0);
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.sb2), TRUE, TRUE, 0);
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.sb3), TRUE, TRUE, 0);
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.sb4), TRUE, TRUE, 0);
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox2), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), FALSE, FALSE, 5);
lib->gui.button1=gtk_button_new_with_label(_("capture image(s)"));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(lib->gui.button1), FALSE, FALSE, 5);
g_object_set(G_OBJECT(lib->gui.tb1), "tooltip-text", _("toggle delayed capture mode"), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.tb2), "tooltip-text", _("toggle sequenced capture mode"), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.tb3), "tooltip-text", _("toggle bracketed capture mode"), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.sb1), "tooltip-text", _("the count of seconds before actually doing a capture"), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.sb2), "tooltip-text", _("the amount of images to capture in a sequence,\nyou can use this in conjuction with delayed mode to create stop-motion sequences."), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.sb3), "tooltip-text", _("the amount of brackets on each side of centered shoot, amount of images = (brackets*2)+1."), (char *)NULL);
g_object_set(G_OBJECT( lib->gui.sb4), "tooltip-text", _("the amount of steps per bracket, steps is camera configurable and usally 3 steps per stop\nwith other words, 3 steps is 1EV exposure step between brackets."), (char *)NULL);
g_signal_connect(G_OBJECT(lib->gui.tb1), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb2), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb3), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.button1), "clicked", G_CALLBACK(_capture_button_clicked), lib);
gtk_widget_set_sensitive( GTK_WIDGET(lib->gui.sb1),FALSE);
gtk_widget_set_sensitive( GTK_WIDGET(lib->gui.sb2),FALSE);
gtk_widget_set_sensitive( GTK_WIDGET(lib->gui.sb3),FALSE);
gtk_widget_set_sensitive( GTK_WIDGET(lib->gui.sb4),FALSE);
// Camera settings
dt_lib_camera_property_t *prop;
gtk_box_pack_start(GTK_BOX(self->widget), dtgtk_label_new(_("properties"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT), TRUE, TRUE, 0);
lib->gui.pvbox1 = GTK_BOX(gtk_vbox_new(TRUE, 0));
lib->gui.pvbox2 = GTK_BOX(gtk_vbox_new(TRUE, 0));
if( (prop=_lib_property_add_new(lib, _("program"),"expprogram"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("focus mode"),"focusmode"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
else if( (prop=_lib_property_add_new(lib, _("focus mode"),"drivemode"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("aperture"),"f-number"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
else if( (prop=_lib_property_add_new(lib, _("aperture"),"aperture"))!=NULL ) // for Canon cameras
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("focal length"),"focallength"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("shutterspeed2"),"shutterspeed2"))!=NULL )
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
else if( (prop=_lib_property_add_new(lib, _("shutterspeed"),"shutterspeed"))!=NULL ) // Canon, again
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("iso"),"iso"))!=NULL)
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("wb"),"whitebalance"))!=NULL)
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("quality"),"imagequality"))!=NULL)
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
if( (prop=_lib_property_add_new(lib, _("size"),"imagesize"))!=NULL)
{
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->values), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start(lib->gui.pvbox1, GTK_WIDGET(prop->label), TRUE, TRUE, 0);
gtk_box_pack_start(lib->gui.pvbox2, GTK_WIDGET(hbox), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(prop->osd), "clicked", G_CALLBACK(_osd_button_clicked), prop);
}
/* add user widgets */
GSList *options = dt_conf_all_string_entries ("plugins/capture/tethering/properties");
if (options)
{
GSList *item = options;
if (item)
{
do
{
dt_conf_string_entry_t *entry = (dt_conf_string_entry_t *)item->data;
/* get the label from key */
char *p=entry->key;
while (p++<entry->key+strlen(entry->key)) if (*p=='_') *p=' ';
if ((prop = _lib_property_add_new (lib, entry->key,entry->value )) != NULL)
{
hbox = GTK_BOX (gtk_hbox_new(FALSE, 0));
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (prop->values), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start (lib->gui.pvbox1, GTK_WIDGET (prop->label), TRUE, TRUE, 0);
gtk_box_pack_start (lib->gui.pvbox2, GTK_WIDGET (hbox), TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (prop->osd), "clicked", G_CALLBACK (_osd_button_clicked), prop);
}
}
while ( (item = g_slist_next (item)) != NULL );
}
}
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(lib->gui.pvbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(lib->gui.pvbox2), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), FALSE, FALSE, 5);
/* build the propertymenu */
dt_camctl_camera_build_property_menu (darktable.camctl,NULL,&lib->gui.properties_menu,G_CALLBACK(_property_choice_callback),lib);
// user specified properties
gtk_box_pack_start (GTK_BOX (self->widget), dtgtk_label_new (_("additional properties"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT), TRUE, TRUE, 5);
vbox1 = GTK_BOX (gtk_vbox_new (TRUE, 0));
vbox2 = GTK_BOX (gtk_vbox_new (TRUE, 0));
gtk_box_pack_start (vbox1, GTK_WIDGET ( gtk_label_new (_("label"))), TRUE, TRUE, 0);
lib->gui.plabel = gtk_entry_new ();
dt_gui_key_accel_block_on_focus (lib->gui.plabel);
gtk_box_pack_start (vbox2, GTK_WIDGET ( lib->gui.plabel ), TRUE, TRUE, 0);
hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start (vbox1, GTK_WIDGET ( gtk_label_new (_("property"))), TRUE, TRUE, 0);
GtkWidget *widget = gtk_button_new_with_label("O");
g_signal_connect (G_OBJECT (widget), "clicked", G_CALLBACK (_show_property_popupmenu_clicked), lib);
lib->gui.pname = gtk_entry_new ();
dt_gui_key_accel_block_on_focus (lib->gui.pname);
gtk_box_pack_start (hbox, GTK_WIDGET ( lib->gui.pname ), TRUE, TRUE, 0);
gtk_box_pack_start (hbox, GTK_WIDGET ( widget ), FALSE, FALSE, 0);
gtk_box_pack_start (vbox2, GTK_WIDGET ( hbox ), TRUE, TRUE, 0);
hbox = GTK_BOX (gtk_hbox_new(FALSE, 0));
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (vbox1), FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (vbox2), TRUE, TRUE, 5);
widget = gtk_button_new_with_label (_("add user property"));
g_signal_connect (G_OBJECT (widget), "clicked", G_CALLBACK (_add_property_button_clicked), lib);
gtk_widget_show(widget);
gtk_box_pack_start (GTK_BOX (self->widget), GTK_WIDGET(hbox), FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (self->widget), GTK_WIDGET (widget), TRUE, TRUE, 5);
// Get camera model name
lib->data.camera_model=dt_camctl_camera_get_model(darktable.camctl,NULL);
// Register listener
dt_camctl_register_listener(darktable.camctl,lib->data.listener);
dt_camctl_tether_mode(darktable.camctl,NULL,TRUE);
}
int32_t dt_camera_import_job_run(dt_job_t *job)
{
dt_camera_import_t *t = (dt_camera_import_t *)job->param;
dt_control_log(_("starting to import images from camera"));
// Setup a new filmroll to import images to....
t->film=(dt_film_t*)g_malloc(sizeof(dt_film_t));
dt_film_init(t->film);
gchar* fixed_path = dt_util_fix_path(t->path);
g_free(t->path);
t->path = fixed_path;
dt_variables_expand( t->vp, t->path, FALSE );
sprintf(t->film->dirname,"%s",dt_variables_get_result(t->vp));
dt_pthread_mutex_lock(&t->film->images_mutex);
t->film->ref++;
dt_pthread_mutex_unlock(&t->film->images_mutex);
// Create recursive directories, abort if no access
if( g_mkdir_with_parents(t->film->dirname,0755) == -1 )
{
dt_control_log(_("failed to create import path `%s', import aborted."), t->film->dirname);
return 1;
}
// Import path is ok, lets actually create the filmroll in database..
if(dt_film_new(t->film,t->film->dirname) > 0)
{
int total = g_list_length( t->images );
char message[512]= {0};
sprintf(message, ngettext ("importing %d image from camera", "importing %d images from camera", total), total );
t->bgj = dt_control_backgroundjobs_create(darktable.control, 0, message);
// Switch to new filmroll
dt_film_open(t->film->id);
dt_ctl_switch_mode_to(DT_LIBRARY);
// register listener
dt_camctl_listener_t listener= {0};
listener.data=t;
listener.image_downloaded=_camera_image_downloaded;
listener.request_image_path=_camera_import_request_image_path;
listener.request_image_filename=_camera_import_request_image_filename;
// start download of images
dt_camctl_register_listener(darktable.camctl,&listener);
dt_camctl_import(darktable.camctl,t->camera,t->images,dt_conf_get_bool("plugins/capture/camera/import/delete_originals"));
dt_camctl_unregister_listener(darktable.camctl,&listener);
dt_control_backgroundjobs_destroy(darktable.control, t->bgj);
dt_variables_params_destroy(t->vp);
}
else
dt_control_log(_("failed to create filmroll for camera import, import aborted."));
dt_pthread_mutex_lock(&t->film->images_mutex);
t->film->ref--;
dt_pthread_mutex_unlock(&t->film->images_mutex);
return 0;
}
static int32_t dt_camera_capture_job_run(dt_job_t *job)
{
dt_camera_capture_t *params = dt_control_job_get_params(job);
int total;
char message[512]= {0};
double fraction=0;
total = params->total = params->brackets ? params->count * params->brackets : params->count;
snprintf(message, sizeof(message), ngettext ("capturing %d image", "capturing %d images", total), total );
pthread_mutex_init(¶ms->mutex, NULL);
pthread_cond_init(¶ms->done, NULL);
// register listener
dt_camctl_listener_t *listener;
listener = g_malloc0(sizeof(dt_camctl_listener_t));
listener->data = params;
listener->image_downloaded = _camera_capture_image_downloaded;
listener->request_image_path = _camera_request_image_path;
listener->request_image_filename = _camera_request_image_filename;
dt_camctl_register_listener(darktable.camctl, listener);
/* try to get exp program mode for nikon */
char *expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "expprogram");
/* if fail, lets try fetching mode for cannon */
if(!expprogram)
expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "autoexposuremode");
/* Fetch all values for shutterspeed and initialize current value */
GList *values=NULL;
gconstpointer original_value=NULL;
const char *cvalue = dt_camctl_camera_get_property(darktable.camctl, NULL, "shutterspeed");
const char *value = dt_camctl_camera_property_get_first_choice(darktable.camctl, NULL, "shutterspeed");
/* get values for bracketing */
if (params->brackets && expprogram && expprogram[0]=='M' && value && cvalue)
{
do
{
// Add value to list
values = g_list_append(values, g_strdup(value));
// Check if current values is the same as original value, then lets store item ptr
if (strcmp(value,cvalue) == 0)
original_value = g_list_last(values)->data;
}
while ((value = dt_camctl_camera_property_get_next_choice(darktable.camctl, NULL, "shutterspeed")) != NULL);
}
else
{
/* if this was an intended bracket capture bail out */
if(params->brackets)
{
dt_control_log(_("please set your camera to manual mode first!"));
pthread_mutex_lock(¶ms->mutex);
pthread_cond_wait(¶ms->done, ¶ms->mutex);
pthread_mutex_unlock(¶ms->mutex);
pthread_mutex_destroy(¶ms->mutex);
pthread_cond_destroy(¶ms->done);
dt_import_session_destroy(params->shared.session);
dt_camctl_unregister_listener(darktable.camctl, listener);
g_free(listener);
free(params);
return 1;
}
}
/* create the bgjob plate */
const guint *jid = dt_control_backgroundjobs_create(darktable.control, 0, message);
GList *current_value = g_list_find(values,original_value);
for(uint32_t i=0; i < params->count; i++)
{
// Delay if active
if(params->delay)
g_usleep(params->delay*G_USEC_PER_SEC);
for(uint32_t b=0; b < (params->brackets*2)+1; b++)
{
// If bracket capture, lets set change shutterspeed
if (params->brackets)
{
if (b == 0)
{
// First bracket, step down time with (steps*brackets), also check so we never set the longest shuttertime which would be bulb mode
for(uint32_t s=0; s < (params->steps * params->brackets); s++)
if (g_list_next(current_value) && g_list_next(g_list_next(current_value)))
current_value = g_list_next(current_value);
}
else
{
// Step up with (steps)
for(uint32_t s=0; s < params->steps; s++)
if(g_list_previous(current_value))
current_value = g_list_previous(current_value);
}
}
// set the time property for bracket capture
if (params->brackets && current_value)
dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data);
// Capture image
dt_camctl_camera_capture(darktable.camctl,NULL);
fraction += 1.0/total;
dt_control_backgroundjobs_progress(darktable.control, jid, fraction);
}
// lets reset to original value before continue
if (params->brackets)
{
current_value = g_list_find(values,original_value);
dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data);
}
}
/* wait for last image capture before exiting job */
pthread_mutex_lock(¶ms->mutex);
pthread_cond_wait(¶ms->done, ¶ms->mutex);
pthread_mutex_unlock(¶ms->mutex);
pthread_mutex_destroy(¶ms->mutex);
pthread_cond_destroy(¶ms->done);
/* cleanup */
dt_control_backgroundjobs_destroy(darktable.control, jid);
dt_import_session_destroy(params->shared.session);
dt_camctl_unregister_listener(darktable.camctl, listener);
g_free(listener);
// free values
if(values)
{
g_list_free_full(values, g_free);
}
free(params);
return 0;
}
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);
}
