static GnomeVFSResult do_get_file_info_from_handle (
GnomeVFSMethod *method,
GnomeVFSMethodHandle *handle,
GnomeVFSFileInfo *info,
GnomeVFSFileInfoOptions options,
GnomeVFSContext *context)
{
CameraFileInfo camera_info;
GnomeVFSResult result;
FileHandle *fh = (FileHandle *) handle;
const char *name;
G_LOCK (cameras);
gp_file_get_name (fh->file, &name);
result = GNOME_VFS_RESULT (gp_camera_file_get_info (fh->camera,
fh->dirname,
name,
&camera_info,
NULL));
if (result != GNOME_VFS_OK) {
G_UNLOCK (cameras);
return (result);
}
get_info_from_camera_info (&camera_info, fh->preview, info);
G_UNLOCK (cameras);
return (GNOME_VFS_OK);
}
bool GPCamera::setLockItem(const QString& folder, const QString& itemName, bool lock)
{
#ifdef HAVE_GPHOTO2
int errorCode;
d->status->cancel = false;
CameraFileInfo info;
errorCode = gp_camera_file_get_info(d->camera, QFile::encodeName(folder).constData(),
QFile::encodeName(itemName).constData(), &info, d->status->context);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get camera item properties!";
printGphotoErrorDescription(errorCode);
return false;
}
if (info.file.fields & GP_FILE_INFO_PERMISSIONS)
{
if (lock)
{
// Lock the file to set read only flag
info.file.permissions = (CameraFilePermissions)GP_FILE_PERM_READ;
}
else
{
// Unlock the file to set read/write flag
info.file.permissions = (CameraFilePermissions)(GP_FILE_PERM_READ | GP_FILE_PERM_DELETE);
}
}
// Some gphoto2 drivers need to have only the right flag at on to process properties update in camera.
info.file.fields = GP_FILE_INFO_PERMISSIONS;
info.preview.fields = GP_FILE_INFO_NONE;
info.audio.fields = GP_FILE_INFO_NONE;
errorCode = gp_camera_file_set_info(d->camera, QFile::encodeName(folder).constData(),
QFile::encodeName(itemName).constData(), info, d->status->context);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to set camera item lock properties!";
printGphotoErrorDescription(errorCode);
return false;
}
return true;
#else
Q_UNUSED(folder);
Q_UNUSED(itemName);
Q_UNUSED(lock);
return false;
#endif /* HAVE_GPHOTO2 */
}
// TODO We need to complete this function to remove Val_unit
CAMLprim
value caml_gp_camera_file_get_info(value camera_val, value folder_val, \
value fname_val, value context_val) {
CAMLparam4(camera_val, folder_val, fname_val, context_val);
Camera *camera = Camera_val(camera_val);
GPContext *context = Context_val(context_val);
const char *folder = String_val(folder_val);
const char *fname = String_val(fname_val);
CameraFileInfo info;
int ret = gp_camera_file_get_info (camera, folder, fname, &info, context);
CHECK_RESULT(ret);
CAMLreturn(Val_unit);
}
void Camera::for_each_file_in_folder(const FileFunc& func, const std::string& folder) {
int ret;
CameraList *files;
gp_list_new(&files);
if ((ret = gp_camera_folder_list_files(camera, folder.c_str(), files, ctx->context)) < GP_OK) {
throw Exception("gp_camera_folder_list_files", ret);
}
for (int i = 0; i < gp_list_count(files); ++i) {
std::string file_name;
{
const char *c_file_name;
gp_list_get_name(files, i, &c_file_name);
file_name = c_file_name;
}
CameraFileInfo file_info;
if ((ret = gp_camera_file_get_info(camera, folder.c_str(), file_name.c_str(), &file_info, ctx->context)) < GP_OK) {
throw Exception("gp_camera_file_get_info", ret);
}
FileInfo info;
info.folder = folder;
info.name = file_name;
if (file_info.file.fields & GP_FILE_INFO_MTIME) {
info.fields |= FILE_INFO_TIME;
info.time = file_info.file.mtime;
}
if (file_info.file.fields & GP_FILE_INFO_TYPE) {
info.fields |= FILE_INFO_TYPE;
info.type = file_info.file.type;
}
func(info);
}
gp_list_free(files);
CameraList *folders;
gp_list_new(&folders);
if ((ret = gp_camera_folder_list_folders(camera, folder.c_str(), folders, ctx->context)) < GP_OK) {
throw Exception("gp_camera_folder_list_folders", ret);
}
for (int i = 0; i < gp_list_count(folders); ++i) {
const char *child_name;
gp_list_get_name(folders, i, &child_name);
std::string absolute_path = folder + "/" + child_name;
for_each_file_in_folder(func, absolute_path);
}
gp_list_free(folders);
}
static int
recursive_directory(Camera *camera, const char *folder, GPContext *context, int *foundfile) {
int i, ret;
CameraList *list;
const char *newfile;
CameraFileInfo fileinfo;
CameraFile *file;
ret = gp_list_new (&list);
if (ret < GP_OK) {
printf ("Could not allocate list.\n");
return ret;
}
ret = gp_camera_folder_list_folders (camera, folder, list, context);
if (ret < GP_OK) {
printf ("Could not list folders.\n");
gp_list_free (list);
return ret;
}
gp_list_sort (list);
for (i = 0; i < gp_list_count (list); i++) {
const char *newfolder;
char *buf;
int havefile = 0;
gp_list_get_name (list, i, &newfolder);
buf = malloc (strlen(folder) + 1 + strlen(newfolder) + 1);
strcpy(buf, folder);
if (strcmp(folder,"/")) /* avoid double / */
strcat(buf, "/");
strcat(buf, newfolder);
ret = recursive_directory (camera, buf, context, &havefile);
free (buf);
if (ret != GP_OK) {
gp_list_free (list);
printf ("Failed to recursively list folders.\n");
return ret;
}
if (havefile) /* only look for the first directory with a file */
break;
}
gp_list_reset (list);
ret = gp_camera_folder_list_files (camera, folder, list, context);
if (ret < GP_OK) {
gp_list_free (list);
printf ("Could not list files.\n");
return ret;
}
gp_list_sort (list);
if (gp_list_count (list) <= 0) {
gp_list_free (list);
return GP_OK;
}
gp_list_get_name (list, 0, &newfile); /* only entry 0 needed */
ret = gp_camera_file_get_info (camera, folder, newfile, &fileinfo, context);
if (ret != GP_OK) {
gp_list_free (list);
printf ("Could not get file info.\n");
return ret;
}
/* Trigger the ptp things */
gp_file_new (&file);
ret = gp_camera_file_get (camera, folder, newfile, GP_FILE_TYPE_METADATA, file, context);
if ((ret != GP_OK) && (ret != GP_ERROR_NOT_SUPPORTED)) {
gp_list_free (list);
printf ("Could not get file metadata.\n");
return ret;
}
gp_file_free (file);
if (foundfile) *foundfile = 1;
gp_list_free (list);
return GP_OK;
}
int _camctl_recursive_get_previews(const dt_camctl_t *c,dt_camera_preview_flags_t flags,char *path)
{
CameraList *files;
CameraList *folders;
const char *filename;
const char *foldername;
gp_list_new (&files);
gp_list_new (&folders);
// Process files in current folder...
if( gp_camera_folder_list_files(c->active_camera->gpcam,path,files,c->gpcontext) == GP_OK )
{
for(int i=0; i < gp_list_count(files); i++)
{
gp_list_get_name (files, i, &filename);
char *file = g_strconcat(path, "/", filename, NULL);
// Lets check the type of file...
CameraFileInfo cfi;
if( gp_camera_file_get_info(c->active_camera->gpcam, path, filename,&cfi,c->gpcontext) == GP_OK)
{
CameraFile *preview=NULL;
CameraFile *exif=NULL;
/*
* Fetch image preview if flagged...
*/
if( flags & CAMCTL_IMAGE_PREVIEW_DATA )
{
gp_file_new(&preview);
if( gp_camera_file_get(c->active_camera->gpcam, path, filename, GP_FILE_TYPE_PREVIEW,preview,c->gpcontext) < GP_OK )
{
// No preview for file lets check image size to se if we should download full image for preview...
if( cfi.file.size > 0 && cfi.file.size < 512000 )
if( gp_camera_file_get(c->active_camera->gpcam, path, filename, GP_FILE_TYPE_NORMAL,preview,c->gpcontext) < GP_OK )
{
preview=NULL;
dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to retreive preview of file %s\n",filename);
}
}
}
if( flags & CAMCTL_IMAGE_EXIF_DATA )
{
gp_file_new(&exif);
if( gp_camera_file_get(c->active_camera->gpcam, path, filename, GP_FILE_TYPE_EXIF,exif,c->gpcontext) < GP_OK )
{
exif=NULL;
dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to retreive exif of file %s\n",filename);
}
}
// let's dispatch to host app.. return if we should stop...
if (!_dispatch_camera_storage_image_filename(c,c->active_camera,file,preview,exif))
{
g_free(file);
return 0;
}
}
else
dt_print(DT_DEBUG_CAMCTL,"[camera_control] failed to get file information of %s in folder %s on device\n",filename,path);
g_free(file);
}
}
// Recurse into folders in current folder...
if( gp_camera_folder_list_folders(c->active_camera->gpcam,path,folders,c->gpcontext)==GP_OK)
{
for(int i=0; i < gp_list_count(folders); i++)
{
char buffer[4096]= {0};
g_strlcat(buffer,path, 4096);
if(path[1]!='\0') g_strlcat(buffer,"/", 4096);
gp_list_get_name (folders, i, &foldername);
g_strlcat(buffer,foldername, 4096);
if( !_camctl_recursive_get_previews(c,flags,buffer))
return 0;
}
}
gp_list_free (files);
gp_list_free (folders);
return 1;
}
static gint
on_button_press_event (GtkWidget *widget, GdkEventButton *event,
GtkamList *list)
{
GtkTreePath *path = NULL;
GtkWidget *w;
GtkamCamera *camera;
CameraAbilities a;
switch (event->button) {
case 3:
if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (list),
event->x, event->y, &path, NULL, NULL, NULL))
return (FALSE);
gtk_tree_model_get_iter (GTK_TREE_MODEL (list->priv->store),
&list->priv->iter, path);
gtk_tree_path_free (path);
camera = gtkam_list_get_camera_from_iter (list,
&list->priv->iter);
gp_camera_get_abilities (camera->camera, &a);
/* What operations does the camera support? */
w = gtk_item_factory_get_widget (list->priv->factory,
"/Delete");
gtk_widget_set_sensitive (w,
(a.file_operations & GP_FILE_OPERATION_DELETE));
#ifdef HAVE_BONOBO
{
Bonobo_ServerInfoList *l;
guint i;
GtkWidget *item, *c;
CORBA_Environment ev;
CameraFileInfo finfo;
gchar *fo, *fi, *query;
ViewAsData *d;
GList *cl;
w = gtk_item_factory_get_widget (list->priv->factory, "/View with...");
c = gtk_item_factory_get_widget (list->priv->factory,
"/View with.../Built-in viewer");
cl = gtk_container_get_children (GTK_CONTAINER (w));
for (i = 0; i < g_list_length (cl); i++) {
if (g_list_nth_data (cl, i) != c)
gtk_container_remove (GTK_CONTAINER (w),
GTK_WIDGET (g_list_nth_data (cl, i)));
}
fo = gtkam_list_get_folder_from_iter (list, &list->priv->iter);
fi = gtkam_list_get_name_from_iter (list, &list->priv->iter);
gp_camera_file_get_info (camera->camera, fo, fi, &finfo, NULL);
g_free (fo);
g_free (fi);
if (finfo.file.fields & GP_FILE_INFO_TYPE) {
CORBA_exception_init (&ev);
query = g_strconcat ("repo_ids.has ('IDL:Bonobo/Control:1.0') AND "
"bonobo:supported_mime_types.has ('",
finfo.file.type, "')", NULL);
l = bonobo_activation_query (query, NULL, &ev);
g_free (query);
CORBA_exception_free (&ev);
if (l && l->_length) {
for (i = 0; i < l->_length; i++) {
Bonobo_ServerInfo *si = &l->_buffer[i];
const gchar *n;
if (!si->iid)
continue;
n = bonobo_server_info_prop_lookup (si, "name", NULL);
if (!n)
n = si->iid;
item = gtk_menu_item_new_with_label (n);
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (w), item);
d = g_new0 (ViewAsData, 1);
d->list = list;
d->camera = camera;
g_object_ref (G_OBJECT (d->camera));
d->folder = gtkam_list_get_folder_from_iter (list,
&list->priv->iter);
d->file = gtkam_list_get_name_from_iter (list,
&list->priv->iter);
d->iid = g_strdup (si->iid);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (on_view_as_activate), d);
g_signal_connect (G_OBJECT (item), "destroy",
G_CALLBACK (on_menu_item_destroy), d);
}
}
if (l)
CORBA_free (l);
}
}
#endif
gtk_item_factory_popup (list->priv->factory, event->x_root,
event->y_root, event->button, event->time);
return (TRUE);
default:
return (FALSE);
}
}
void GPCamera::getItemInfoInternal(const QString& folder, const QString& itemName, CamItemInfo& info, bool useMetadata)
{
#ifdef HAVE_GPHOTO2
info.folder = folder;
info.name = itemName;
d->status->cancel = false;
info.previewPossible = m_captureImagePreviewSupport;
CameraFileInfo cfinfo;
gp_camera_file_get_info(d->camera, QFile::encodeName(info.folder).constData(),
QFile::encodeName(info.name).constData(), &cfinfo, d->status->context);
// if preview has size field, it's a valid preview most likely, otherwise we'll skip it later on
if (cfinfo.preview.fields & GP_FILE_INFO_SIZE)
{
info.previewPossible = true;
}
if (cfinfo.file.fields & GP_FILE_INFO_STATUS)
{
if (cfinfo.file.status == GP_FILE_STATUS_DOWNLOADED)
{
info.downloaded = CamItemInfo::DownloadedYes;
}
}
if (cfinfo.file.fields & GP_FILE_INFO_SIZE)
{
info.size = cfinfo.file.size;
}
if (cfinfo.file.fields & GP_FILE_INFO_PERMISSIONS)
{
if (cfinfo.file.permissions & GP_FILE_PERM_READ)
{
info.readPermissions = 1;
}
else
{
info.readPermissions = 0;
}
if (cfinfo.file.permissions & GP_FILE_PERM_DELETE)
{
info.writePermissions = 1;
}
else
{
info.writePermissions = 0;
}
}
/* The mime type returned by Gphoto2 is dummy with all RAW files.
if (cfinfo.file.fields & GP_FILE_INFO_TYPE)
info.mime = cfinfo.file.type;
*/
info.mime = mimeType(info.name.section(QLatin1Char('.'), -1).toLower());
if (!info.mime.isEmpty())
{
if (useMetadata)
{
// Try to use file metadata
DMetadata meta;
getMetadata(folder, itemName, meta);
fillItemInfoFromMetadata(info, meta);
// Fall back to camera file system info
if (info.ctime.isNull())
{
if (cfinfo.file.fields & GP_FILE_INFO_MTIME)
{
info.ctime = QDateTime::fromTime_t(cfinfo.file.mtime);
}
else
{
info.ctime = QDateTime::currentDateTime();
}
}
}
else
{
// Only use properties provided by camera.
if (cfinfo.file.fields & GP_FILE_INFO_MTIME)
{
info.ctime = QDateTime::fromTime_t(cfinfo.file.mtime);
}
else
{
info.ctime = QDateTime::currentDateTime();
}
if (cfinfo.file.fields & GP_FILE_INFO_WIDTH)
{
info.width = cfinfo.file.width;
}
if (cfinfo.file.fields & GP_FILE_INFO_HEIGHT)
{
info.height = cfinfo.file.height;
}
}
}
#else
Q_UNUSED(folder);
Q_UNUSED(itemName);
Q_UNUSED(info);
Q_UNUSED(useMetadata);
#endif /* HAVE_GPHOTO2 */
}
bool GPCamera::capture(CamItemInfo& itemInfo)
{
#ifdef HAVE_GPHOTO2
int errorCode;
CameraFilePath path;
d->status->cancel = false;
errorCode = gp_camera_capture(d->camera, GP_CAPTURE_IMAGE, &path, d->status->context);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to take camera capture!";
printGphotoErrorDescription(errorCode);
return false;
}
// Get new camera item information.
itemInfo.folder = QString::fromUtf8(path.folder);
itemInfo.name = QString::fromUtf8(path.name);
CameraFileInfo info;
errorCode = gp_camera_file_get_info(d->camera, QFile::encodeName(itemInfo.folder).constData(),
QFile::encodeName(itemInfo.name).constData(), &info,
d->status->context);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get camera item information!";
printGphotoErrorDescription(errorCode);
return false;
}
itemInfo.ctime = QDateTime();
itemInfo.mime = QString();
itemInfo.size = -1;
itemInfo.width = -1;
itemInfo.height = -1;
itemInfo.downloaded = CamItemInfo::DownloadUnknown;
itemInfo.readPermissions = -1;
itemInfo.writePermissions = -1;
/* The mime type returned by Gphoto2 is dummy with all RAW files.
if (info.file.fields & GP_FILE_INFO_TYPE)
itemInfo.mime = info.file.type;*/
itemInfo.mime = mimeType(itemInfo.name.section(QLatin1Char('.'), -1).toLower());
if (info.file.fields & GP_FILE_INFO_MTIME)
{
itemInfo.ctime = QDateTime::fromTime_t(info.file.mtime);
}
if (info.file.fields & GP_FILE_INFO_SIZE)
{
itemInfo.size = info.file.size;
}
if (info.file.fields & GP_FILE_INFO_WIDTH)
{
itemInfo.width = info.file.width;
}
if (info.file.fields & GP_FILE_INFO_HEIGHT)
{
itemInfo.height = info.file.height;
}
if (info.file.fields & GP_FILE_INFO_STATUS)
{
if (info.file.status == GP_FILE_STATUS_DOWNLOADED)
{
itemInfo.downloaded = CamItemInfo::DownloadedYes;
}
else
{
itemInfo.downloaded = CamItemInfo::DownloadedNo;
}
}
if (info.file.fields & GP_FILE_INFO_PERMISSIONS)
{
if (info.file.permissions & GP_FILE_PERM_READ)
{
itemInfo.readPermissions = 1;
}
else
{
itemInfo.readPermissions = 0;
}
if (info.file.permissions & GP_FILE_PERM_DELETE)
{
itemInfo.writePermissions = 1;
}
else
{
itemInfo.writePermissions = 0;
}
}
return true;
#else
Q_UNUSED(itemInfo);
return false;
#endif /* HAVE_GPHOTO2 */
}
bool GPCamera::uploadItem(const QString& folder, const QString& itemName, const QString& localFile, CamItemInfo& itemInfo)
{
#ifdef HAVE_GPHOTO2
int errorCode;
CameraFile* cfile = 0;
errorCode = gp_file_new(&cfile);
d->status->cancel = false;
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to init new camera file instance!";
printGphotoErrorDescription(errorCode);
return false;
}
errorCode = gp_file_open(cfile, QFile::encodeName(localFile).constData());
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to open file!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
errorCode = gp_file_set_name(cfile, QFile::encodeName(itemName).constData());
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to rename item from camera!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
#ifdef HAVE_GPHOTO25
errorCode = gp_camera_folder_put_file(d->camera,
QFile::encodeName(folder).constData(),
QFile::encodeName(itemName).constData(),
GP_FILE_TYPE_NORMAL,
cfile,
d->status->context);
#else
errorCode = gp_camera_folder_put_file(d->camera,
QFile::encodeName(folder).constData(),
cfile,
d->status->context);
#endif
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to upload item to camera!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
// Get new camera item information.
itemInfo.name = itemName;
itemInfo.folder = folder;
CameraFileInfo info;
errorCode = gp_camera_file_get_info(d->camera, QFile::encodeName(folder).constData(),
QFile::encodeName(itemName).constData(), &info, d->status->context);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get camera item information!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
itemInfo.ctime = QDateTime();
itemInfo.mime = QString();
itemInfo.size = -1;
itemInfo.width = -1;
itemInfo.height = -1;
itemInfo.downloaded = CamItemInfo::DownloadUnknown;
itemInfo.readPermissions = -1;
itemInfo.writePermissions = -1;
/* The mime type returned by Gphoto2 is dummy with all RAW files.
if (info.file.fields & GP_FILE_INFO_TYPE)
itemInfo.mime = info.file.type;
*/
itemInfo.mime = mimeType(itemInfo.name.section(QLatin1Char('.'), -1).toLower());
if (info.file.fields & GP_FILE_INFO_MTIME)
{
itemInfo.ctime = QDateTime::fromTime_t(info.file.mtime);
}
if (info.file.fields & GP_FILE_INFO_SIZE)
{
itemInfo.size = info.file.size;
}
if (info.file.fields & GP_FILE_INFO_WIDTH)
{
itemInfo.width = info.file.width;
}
if (info.file.fields & GP_FILE_INFO_HEIGHT)
{
itemInfo.height = info.file.height;
}
if (info.file.fields & GP_FILE_INFO_STATUS)
{
if (info.file.status == GP_FILE_STATUS_DOWNLOADED)
{
itemInfo.downloaded = CamItemInfo::DownloadedYes;
}
else
{
itemInfo.downloaded = CamItemInfo::DownloadedNo;
}
}
if (info.file.fields & GP_FILE_INFO_PERMISSIONS)
{
if (info.file.permissions & GP_FILE_PERM_READ)
{
itemInfo.readPermissions = 1;
}
else
{
itemInfo.readPermissions = 0;
}
if (info.file.permissions & GP_FILE_PERM_DELETE)
{
itemInfo.writePermissions = 1;
}
else
{
itemInfo.writePermissions = 0;
}
}
gp_file_unref(cfile);
return true;
#else
Q_UNUSED(folder);
Q_UNUSED(itemName);
Q_UNUSED(localFile);
Q_UNUSED(itemInfo);
return false;
#endif /* HAVE_GPHOTO2 */
}
static GnomeVFSResult do_get_file_info (
GnomeVFSMethod* method,
GnomeVFSURI* uri,
GnomeVFSFileInfo* info,
GnomeVFSFileInfoOptions options,
GnomeVFSContext* context)
{
GnomeVFSResult result;
GnomeVFSURI *parent;
Camera *camera;
CameraFileInfo camera_info;
CameraList *list;
const gchar *path, *name;
char *basename;
guint i;
int count;
printf ("ENTER: do_get_file_info (%s)\n", camera_uri_get_path (uri));
G_LOCK (cameras);
/* Is this root? */
if (!gnome_vfs_uri_has_parent (uri)) {
info->name = g_strdup ("/");
info->valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE |
GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE;
info->type = GNOME_VFS_FILE_TYPE_DIRECTORY;
info->mime_type = g_strdup ("x-directory/normal");
G_UNLOCK (cameras);
return (GNOME_VFS_OK);
}
printf ("Getting camera (do_get_file_info)...\n");
result = get_camera (uri, &camera);
if (result != GNOME_VFS_OK) {
G_UNLOCK (cameras);
return (result);
}
result = GNOME_VFS_RESULT (gp_list_new (&list));
if (result != GNOME_VFS_OK) {
unref_camera (camera);
G_UNLOCK (cameras);
return (result);
}
/*
* We cannot use get_basename here because of potential trailing
* slashes.
*/
basename = gnome_vfs_uri_extract_short_name (uri);
parent = camera_uri_get_parent (uri);
path = camera_uri_get_path (parent);
result = GNOME_VFS_RESULT (gp_camera_folder_list_folders (camera, path,
list, NULL));
if (result != GNOME_VFS_OK) {
gnome_vfs_uri_unref (parent);
unref_camera (camera);
gp_list_free (list);
g_free (basename);
G_UNLOCK (cameras);
return (result);
}
count = gp_list_count (list);
if (count < 0) {
gnome_vfs_uri_unref (parent);
unref_camera (camera);
gp_list_free (list);
g_free (basename);
G_UNLOCK (cameras);
return (GNOME_VFS_RESULT (count));
}
for (i = 0; i < count; i++) {
result = GNOME_VFS_RESULT (gp_list_get_name (list, i, &name));
if (result != GNOME_VFS_OK) {
gnome_vfs_uri_unref (parent);
unref_camera (camera);
gp_list_free (list);
g_free (basename);
G_UNLOCK (cameras);
return (result);
}
if (!strcmp (name, basename)) {
info->name = g_strdup (basename);
info->valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE |
GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE;
info->type = GNOME_VFS_FILE_TYPE_DIRECTORY;
info->mime_type = g_strdup ("x-directory/normal");
gnome_vfs_uri_unref (parent);
unref_camera (camera);
gp_list_free (list);
g_free (basename);
G_UNLOCK (cameras);
printf ("Found folder!\n");
return (GNOME_VFS_OK);
}
}
result = GNOME_VFS_RESULT (gp_camera_folder_list_files (camera, path,
list, NULL));
if (result != GNOME_VFS_OK) {
gnome_vfs_uri_unref (parent);
unref_camera (camera);
gp_list_free (list);
g_free (basename);
G_UNLOCK (cameras);
return (result);
}
count = gp_list_count (list);
if (count < 0) {
gnome_vfs_uri_unref (parent);
unref_camera (camera);
gp_list_free (list);
g_free (basename);
G_UNLOCK (cameras);
return (GNOME_VFS_RESULT (count));
}
for (i = 0; i < count; i++) {
result = GNOME_VFS_RESULT (gp_list_get_name (list, i, &name));
if (result != GNOME_VFS_OK) {
gnome_vfs_uri_unref (parent);
unref_camera (camera);
gp_list_free (list);
g_free (basename);
G_UNLOCK (cameras);
return (result);
}
if (!strcmp (name, basename)) {
result = GNOME_VFS_RESULT (gp_camera_file_get_info (
camera, path, basename, &camera_info,
NULL));
g_free (basename);
unref_camera (camera);
gp_list_free (list);
if (result != GNOME_VFS_OK) {
G_UNLOCK (cameras);
return (result);
}
get_info_from_camera_info (&camera_info, FALSE, info);
gnome_vfs_uri_unref (parent);
G_UNLOCK (cameras);
printf ("Found file!\n");
return (GNOME_VFS_OK);
}
}
gnome_vfs_uri_unref (parent);
g_free (basename);
unref_camera (camera);
gp_list_free (list);
G_UNLOCK (cameras);
return (GNOME_VFS_ERROR_NOT_FOUND);
}
