void
gtkam_chooser_set_camera (GtkamChooser *chooser, GtkamCamera *camera)
{
CameraAbilities a;
GPPortInfo info;
gchar *full_info;
#ifdef HAVE_GP_PORT_INFO_GET_NAME
char *xname,*xpath;
#endif
g_return_if_fail (GTKAM_IS_CHOOSER (chooser));
g_return_if_fail (GTKAM_IS_CAMERA (camera));
gp_camera_get_abilities (camera->camera, &a);
gp_camera_get_port_info (camera->camera, &info);
#ifdef HAVE_GP_PORT_INFO_GET_NAME
gp_port_info_get_name (info, &xname);
gp_port_info_get_path (info, &xpath);
full_info = g_strdup_printf ("%s (%s)", xname, xpath);
#else
full_info = g_strdup_printf ("%s (%s)", info.name, info.path);
#endif
gtk_entry_set_text (chooser->priv->entry_port, full_info);
g_free (full_info);
gtk_entry_set_text (chooser->priv->entry_model, a.model);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (chooser->priv->check_multi), camera->multi);
chooser->priv->needs_update = FALSE;
gtk_widget_set_sensitive (chooser->apply_button, FALSE);
}
static void
on_port_added (GtkamPort *port, const gchar *path, GtkamChooser *chooser)
{
int index;
GPPortInfo info;
gchar *name;
#ifdef HAVE_GP_PORT_INFO_GET_NAME
char *xname, *xpath;
#endif
index = gp_port_info_list_lookup_path (chooser->priv->il, path);
if (index < 0) {
g_warning ("Could not look up path?!?");
return;
}
gp_port_info_list_get_info (chooser->priv->il, index, &info);
#ifdef HAVE_GP_PORT_INFO_GET_NAME
gp_port_info_get_name (info, &xname);
gp_port_info_get_path (info, &xpath);
name = g_strdup_printf ("%s (%s)", xname, xpath);
#else
name = g_strdup_printf ("%s (%s)", info.name, info.path);
#endif
gtk_entry_set_text (chooser->priv->entry_port, name);
g_free (name);
gtkam_chooser_update_for_model (chooser);
chooser->priv->needs_update = TRUE;
gtk_widget_set_sensitive (chooser->apply_button, TRUE);
}
static int
gp_port_serial_open (GPPort *dev)
{
int result, max_tries = 5, i;
#ifdef OS2
int fd;
#endif
char *port;
GPPortInfo info;
result = gp_port_get_info (dev, &info);
if (result < GP_OK) return result;
result = gp_port_info_get_path (info, &port);
if (result < GP_OK) return result;
gp_log (GP_LOG_DEBUG, "gp_port_serial_open", "opening %s", port);
/* Ports are named "serial:/dev/whatever/port" */
port = strchr (port, ':');
if (!port)
return GP_ERROR_UNKNOWN_PORT;
port++;
result = gp_port_serial_lock (dev, port);
if (result != GP_OK) {
for (i = 0; i < max_tries; i++) {
result = gp_port_serial_lock (dev, port);
if (result == GP_OK)
break;
gp_log (GP_LOG_DEBUG, "gphoto2-port-serial",
"Failed to get a lock, trying again...");
sleep (1);
}
CHECK (result);
}
dev->pl->fd = -1;
#if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
dev->pl->fd = open (port, O_RDWR | O_NOCTTY | O_NONBLOCK);
#elif OS2
fd = open (port, O_RDWR | O_BINARY);
dev->pl->fd = open (port, O_RDWR | O_BINARY);
close(fd);
#else
if (dev->pl->fd == -1)
dev->pl->fd = open (port, O_RDWR | O_NOCTTY | O_SYNC | O_NONBLOCK);
#endif
if (dev->pl->fd == -1) {
int saved_errno = errno;
gp_port_set_error (dev, _("Failed to open '%s' (%s)."),
port, strerror(saved_errno));
dev->pl->fd = 0;
return GP_ERROR_IO;
}
return GP_OK;
}
void
gtkam_chooser_set_port_mask (GtkamChooser *chooser, GPPortType types)
{
GtkWidget *dialog;
GPPortInfo info;
int n;
guint i;
GList *list = NULL;
g_return_if_fail (GTKAM_IS_CHOOSER (chooser));
n = gp_port_info_list_count (chooser->priv->il);
if (n < 0) {
dialog = gtkam_error_new (n, NULL, GTK_WIDGET (chooser),
_("Could not get number of ports."));
gtk_widget_show (dialog);
return;
}
/* Search for ports that fulfil the criteria */
for (i = 0; i < n; i++) {
#ifdef HAVE_GP_PORT_INFO_GET_NAME
GPPortType type;
char *xname,*xpath;
#endif
gp_port_info_list_get_info (chooser->priv->il, i, &info);
#ifdef HAVE_GP_PORT_INFO_GET_NAME
gp_port_info_get_type (info, &type);
gp_port_info_get_name (info, &xname);
gp_port_info_get_path (info, &xpath);
if (type & types)
list = g_list_append (list, g_strdup_printf ("%s (%s)",
xname, xpath));
#else
if (info.type & types)
list = g_list_append (list, g_strdup_printf ("%s (%s)",
info.name, info.path));
#endif
}
gtkam_chooser_set_port_list (chooser, list);
}
int
gp_camera_set_port_info (Camera *camera, GPPortInfo info)
{
char *name, *path;
C_PARAMS (camera);
/*
* If the camera is currently initialized, terminate that connection.
* We don't care if we are successful or not.
*/
if (camera->pc->lh)
gp_camera_exit (camera, NULL);
gp_port_info_get_name (info, &name);
gp_port_info_get_path (info, &path);
GP_LOG_D ("Setting port info for port '%s' at '%s'...", name, path);
CR (camera, gp_port_set_info (camera->port, info), NULL);
return (GP_OK);
}
/**
* \param list a CameraAbilitiesList
* \param info_list the GPPortInfoList of ports to use for detection
* \param l a #CameraList that contains the autodetected cameras after the call
* \param context a #GPContext
*
* Tries to detect any camera connected to the computer using the supplied
* list of supported cameras and the supplied info_list of ports.
*
* \return a gphoto2 error code
*/
int
gp_abilities_list_detect (CameraAbilitiesList *list,
GPPortInfoList *info_list, CameraList *l,
GPContext *context)
{
GPPortInfo info;
GPPort *port;
int i, info_count;
CHECK_NULL (list && info_list && l);
gp_list_reset (l);
CHECK_RESULT (info_count = gp_port_info_list_count (info_list));
CHECK_RESULT (gp_port_new (&port));
for (i = 0; i < info_count; i++) {
int res;
char *xpath;
GPPortType type;
CHECK_RESULT (gp_port_info_list_get_info (info_list, i, &info));
CHECK_RESULT (gp_port_set_info (port, info));
gp_port_info_get_type (info, &type);
res = gp_port_info_get_path (info, &xpath);
if (res <GP_OK)
continue;
switch (type) {
case GP_PORT_USB:
case GP_PORT_USB_SCSI:
case GP_PORT_USB_DISK_DIRECT: {
int ability;
res = gp_abilities_list_detect_usb (list, &ability, port);
if (res == GP_OK) {
gp_list_append(l,
list->abilities[ability].model,
xpath);
} else if (res < 0)
gp_port_set_error (port, NULL);
break;
}
case GP_PORT_DISK: {
char *s, path[1024];
struct stat stbuf;
s = strchr (xpath, ':');
if (!s)
break;
s++;
snprintf (path, sizeof(path), "%s/DCIM", s);
if (-1 == stat(path, &stbuf)) {
snprintf (path, sizeof(path), "%s/dcim", s);
if (-1 == stat(path, &stbuf))
continue;
}
gp_list_append (l, "Mass Storage Camera", xpath);
break;
}
case GP_PORT_PTPIP: {
char *s;
s = strchr (xpath, ':');
if (!s) break;
s++;
if (!strlen(s)) break;
gp_list_append (l, "PTP/IP Camera", xpath);
break;
}
default:
/*
* We currently cannot detect any cameras on this
* port
*/
break;
}
}
gp_port_free (port);
return (GP_OK);
}
/**
* Initiate a connection to the \c camera.
*
* @param camera a #Camera
* @param context a #GPContext
* @return a gphoto2 error code
*
* Before calling this function, the
* \c camera should be set up using gp_camera_set_port_path() or
* gp_camera_set_port_name() and gp_camera_set_abilities(). If that has been
* omitted, gphoto2 tries to autodetect any cameras and chooses the first one
* if any cameras are found. It is generally a good idea to call
* gp_camera_exit() after transactions have been completed in order to give
* other applications the chance to access the camera, too.
*
*/
int
gp_camera_init (Camera *camera, GPContext *context)
{
CameraAbilities a;
const char *model, *port;
CameraLibraryInitFunc init_func;
int result;
GP_LOG_D ("Initializing camera...");
C_PARAMS (camera);
/*
* Reset the exit_requested flag. If this flag is set,
* gp_camera_exit will be called as soon as the camera is no
* longer in use (used flag).
*/
camera->pc->exit_requested = 0;
/*
* If the model hasn't been indicated, try to
* figure it out (USB only). Beware of "Directory Browse".
*/
if (strcasecmp (camera->pc->a.model, "Directory Browse") &&
!strcmp ("", camera->pc->a.model)) {
CameraAbilitiesList *al;
GPPortInfoList *il;
int m, p;
char *ppath;
GPPortType ptype;
GPPortInfo info;
CameraList *list;
result = gp_list_new (&list);
if (result < GP_OK)
return result;
GP_LOG_D ("Neither port nor model set. Trying auto-detection...");
/* Call auto-detect and choose the first camera */
CRSL (camera, gp_abilities_list_new (&al), context, list);
CRSL (camera, gp_abilities_list_load (al, context), context, list);
CRSL (camera, gp_port_info_list_new (&il), context, list);
CRSL (camera, gp_port_info_list_load (il), context, list);
CRSL (camera, gp_abilities_list_detect (al, il, list, context), context, list);
if (!gp_list_count (list)) {
gp_abilities_list_free (al);
gp_port_info_list_free (il);
gp_context_error (context, _("Could not detect "
"any camera"));
gp_list_free (list);
return (GP_ERROR_MODEL_NOT_FOUND);
}
p = 0;
CRSL (camera, gp_port_get_info (camera->port, &info), context, list);
CRSL (camera, gp_port_info_get_path (info, &ppath), context, list);
CRSL (camera, gp_port_info_get_type (info, &ptype), context, list);
/* if the port was set before, then use that entry, but not if it is "usb:" */
if ((ptype == GP_PORT_USB) && strlen(ppath) && strcmp(ppath, "usb:")) {
for (p = gp_list_count (list);p--;) {
const char *xp;
gp_list_get_value (list, p, &xp);
if (!strcmp (xp, ppath))
break;
}
if (p<0) {
gp_abilities_list_free (al);
gp_port_info_list_free (il);
gp_context_error (context, _("Could not detect any camera at port %s"), ppath);
gp_list_free (list);
return (GP_ERROR_FILE_NOT_FOUND);
}
}
CRSL (camera, gp_list_get_name (list, p, &model), context, list);
m = gp_abilities_list_lookup_model (al, model);
CRSL (camera, m, context, list);
CRSL (camera, gp_abilities_list_get_abilities (al, m, &a), context, list);
gp_abilities_list_free (al);
CRSL (camera, gp_camera_set_abilities (camera, a), context, list);
CRSL (camera, gp_list_get_value (list, p, &port), context, list);
p = gp_port_info_list_lookup_path (il, port);
CRSL (camera, p, context, list);
CRSL (camera, gp_port_info_list_get_info (il, p, &info), context, list);
CRSL (camera, gp_camera_set_port_info (camera, info), context, list);
gp_port_info_list_free (il);
gp_list_free (list);
}
if (strcasecmp (camera->pc->a.model, "Directory Browse")) {
switch (camera->port->type) {
case GP_PORT_NONE:
gp_context_error (context, _("You have to set the "
"port prior to initialization of the camera."));
return (GP_ERROR_UNKNOWN_PORT);
case GP_PORT_USB:
if (gp_port_usb_find_device (camera->port,
camera->pc->a.usb_vendor,
camera->pc->a.usb_product) != GP_OK) {
CRS (camera, gp_port_usb_find_device_by_class
(camera->port,
camera->pc->a.usb_class,
camera->pc->a.usb_subclass,
camera->pc->a.usb_protocol), context);
}
break;
default:
break;
}
}
/* Load the library. */
GP_LOG_D ("Loading '%s'...", camera->pc->a.library);
lt_dlinit ();
camera->pc->lh = lt_dlopenext (camera->pc->a.library);
if (!camera->pc->lh) {
gp_context_error (context, _("Could not load required "
"camera driver '%s' (%s)."), camera->pc->a.library,
lt_dlerror ());
lt_dlexit ();
return (GP_ERROR_LIBRARY);
}
/* Initialize the camera */
init_func = lt_dlsym (camera->pc->lh, "camera_init");
if (!init_func) {
lt_dlclose (camera->pc->lh);
lt_dlexit ();
camera->pc->lh = NULL;
gp_context_error (context, _("Camera driver '%s' is "
"missing the 'camera_init' function."),
camera->pc->a.library);
return (GP_ERROR_LIBRARY);
}
if (strcasecmp (camera->pc->a.model, "Directory Browse")) {
result = gp_port_open (camera->port);
if (result < 0) {
lt_dlclose (camera->pc->lh);
lt_dlexit ();
camera->pc->lh = NULL;
return (result);
}
}
result = init_func (camera, context);
if (result < 0) {
gp_port_close (camera->port);
lt_dlclose (camera->pc->lh);
lt_dlexit ();
camera->pc->lh = NULL;
memset (camera->functions, 0, sizeof (CameraFunctions));
return (result);
}
/* We don't care if that goes wrong */
#ifdef HAVE_MULTI
gp_port_close (camera->port);
#endif
return (GP_OK);
}
