differentiate among normal image, raw image and metadata

removed raw extension lists on various places and fixed most of the
Exiv2 warnings
todo: configuration and a special icons for unreadable raw or metadata

diff --git a/src/exif-common.c b/src/exif-common.c
index 4fb9b0d..eb827b2 100644 (file)
--- a/src/exif-common.c
+++ b/src/exif-common.c
@@ -336,14 +336,12 @@ ExifData *exif_read_fd(FileData *fd, gint parse_color_profile)
 
        work = fd->parent ? fd->parent->sidecar_files : fd->sidecar_files;
 
-       if (strcasecmp(fd->extension, ".cr2") == 0 || // FIXME: list of formats that can have xmp sidecar, make it configurable
-           strcasecmp(fd->extension, ".nef") == 0)
+       if (filter_file_class(fd->extension, FORMAT_CLASS_RAWIMAGE))
                {
                while(work)
                        {
                        FileData *sfd = work->data;
                        work = work->next;
-                       printf("sfd %s\n", sfd->path);
                        if (strcasecmp(sfd->extension, ".xmp") == 0)
                                {
                                sidecar_path = sfd->path;

diff --git a/src/exiv2.cc b/src/exiv2.cc
index 4d4ca00..cf59670 100644 (file)
--- a/src/exiv2.cc
+++ b/src/exiv2.cc
@@ -42,6 +42,7 @@ extern "C" {
 #include <glib.h> 
 #include "gqview.h"
 #include "exif.h"
+#include "filelist.h"
 
 }
 
@@ -106,7 +107,7 @@ extern "C" {
 
 ExifData *exif_read(gchar *path, gchar *sidecar_path, gint parse_color_profile)
 {
-       printf("exif %s %s\n", path, sidecar_path ? sidecar_path : "-");
+       if (debug) printf("exif read %s,  sidecar: %s\n", path, sidecar_path ? sidecar_path : "-");
        try {
                return new ExifData(path, sidecar_path, parse_color_profile);
        }
@@ -683,8 +684,6 @@ unsigned long RawFile::preview_offset()
 }
 
 
-const static char *raw_ext_list[] = { ".cr2", ".nef", ".pef", ".arw", NULL };
-
 extern "C" gint format_raw_img_exif_offsets_fd(int fd, const gchar *path,
                                    unsigned char *header_data, const guint header_len,
                                    guint *image_offset, guint *exif_offset)
@@ -693,28 +692,8 @@ extern "C" gint format_raw_img_exif_offsets_fd(int fd, const gchar *path,
        unsigned long offset;
 
        /* given image pathname, first do simple (and fast) file extension test */
-/*     if (path)
-               {
-               const gchar *ext;
-               gint match = FALSE;
-               gint i;
+       if (!filter_file_class(path, FORMAT_CLASS_RAWIMAGE)) return 0;
 
-               ext = strrchr(path, '.');
-               if (!ext) return FALSE;
-               
-               for (i = 0; raw_ext_list[i]; i++) 
-                       {
-                       if (strcasecmp(raw_ext_list[i], ext) == 0)
-                               {
-                               match = TRUE;
-                               break;
-                               }
-                       }
-
-               if (!match) return FALSE;
-
-               }
-*/
        try {
                RawFile rf(fd);
                if (debug) printf("%s: offset ", path);

diff --git a/src/filelist.c b/src/filelist.c
index 1bec1b1..24b7dd3 100644 (file)
--- a/src/filelist.c
+++ b/src/filelist.c
@@ -29,6 +29,9 @@ static GList *filter_list = NULL;
 static GList *extension_list = NULL;
 static GList *sidecar_ext_list = NULL;
 
+static GList *file_class_extension_list[FILE_FORMAT_CLASSES];
+
+
 gint ishidden(const gchar *name)
 {
        if (name[0] != '.') return FALSE;
@@ -37,7 +40,7 @@ gint ishidden(const gchar *name)
 }
 
 static FilterEntry *filter_entry_new(const gchar *key, const gchar *description,
-                                    const gchar *extensions, gint enabled)
+                                    const gchar *extensions, FileFormatClass file_class, gint enabled)
 {
        FilterEntry *fe;
 
@@ -46,6 +49,7 @@ static FilterEntry *filter_entry_new(const gchar *key, const gchar *description,
        fe->description = g_strdup(description);
        fe->extensions = g_strdup(extensions);
        fe->enabled = enabled;
+       fe->file_class = file_class;
        
        return fe;
 }
@@ -91,12 +95,12 @@ static gint filter_key_exists(const gchar *key)
        return FALSE;
 }
 
-void filter_add(const gchar *key, const gchar *description, const gchar *extensions, gint enabled)
+void filter_add(const gchar *key, const gchar *description, const gchar *extensions, FileFormatClass file_class, gint enabled)
 {
-       filter_list = g_list_append(filter_list, filter_entry_new(key, description, extensions, enabled));
+       filter_list = g_list_append(filter_list, filter_entry_new(key, description, extensions, file_class, enabled));
 }
 
-void filter_add_unique(const gchar *description, const gchar *extensions, gint enabled)
+void filter_add_unique(const gchar *description, const gchar *extensions, FileFormatClass file_class, gint enabled)
 {
        gchar *key;
        gint n;
@@ -111,11 +115,11 @@ void filter_add_unique(const gchar *description, const gchar *extensions, gint e
                n++;
                }
 
-       filter_add(key, description, extensions, enabled);
+       filter_add(key, description, extensions, file_class, enabled);
        g_free(key);
 }
 
-static void filter_add_if_missing(const gchar *key, const gchar *description, const gchar *extensions, gint enabled)
+static void filter_add_if_missing(const gchar *key, const gchar *description, const gchar *extensions, FileFormatClass file_class, gint enabled)
 {
        GList *work;
 
@@ -126,10 +130,15 @@ static void filter_add_if_missing(const gchar *key, const gchar *description, co
                {
                FilterEntry *fe = work->data;
                work = work->next;
-               if (fe->key && strcmp(fe->key, key) == 0) return;
+               if (fe->key && strcmp(fe->key, key) == 0)
+                       {
+                       if (fe->file_class == FORMAT_CLASS_UNKNOWN)
+                               fe->file_class = file_class;    /* for compatibility */
+                       return;
+                       }
                }
 
-       filter_add(key, description, extensions, enabled);
+       filter_add(key, description, extensions, file_class, enabled);
 }
 
 void filter_reset(void)
@@ -188,7 +197,7 @@ void filter_add_defaults(void)
 
                if (debug) printf("loader reported [%s] [%s] [%s]\n", name, desc, filter->str);
 
-               filter_add_if_missing(name, desc, filter->str, TRUE);
+               filter_add_if_missing(name, desc, filter->str, FORMAT_CLASS_IMAGE, TRUE);
 
                g_free(name);
                g_free(desc);
@@ -198,39 +207,39 @@ void filter_add_defaults(void)
        g_slist_free(list);
 
        /* add defaults even if gdk-pixbuf does not have them, but disabled */
-       filter_add_if_missing("jpeg", "JPEG group", ".jpg;.jpeg;.jpe", FALSE);
-       filter_add_if_missing("png", "Portable Network Graphic", ".png", FALSE);
-       filter_add_if_missing("tiff", "Tiff", ".tif;.tiff", FALSE);
-       filter_add_if_missing("pnm", "Packed Pixel formats", ".pbm;.pgm;.pnm;.ppm", FALSE);
-       filter_add_if_missing("gif", "Graphics Interchange Format", ".gif", FALSE);
-       filter_add_if_missing("xbm", "X bitmap", ".xbm", FALSE);
-       filter_add_if_missing("xpm", "X pixmap", ".xpm", FALSE);
-       filter_add_if_missing("bmp", "Bitmap", ".bmp", FALSE);
-       filter_add_if_missing("ico", "Icon file", ".ico;.cur", FALSE);
-       filter_add_if_missing("ras", "Raster", ".ras", FALSE);
-       filter_add_if_missing("svg", "Scalable Vector Graphics", ".svg", FALSE);
+       filter_add_if_missing("jpeg", "JPEG group", ".jpg;.jpeg;.jpe", FORMAT_CLASS_IMAGE, FALSE);
+       filter_add_if_missing("png", "Portable Network Graphic", ".png", FORMAT_CLASS_IMAGE, FALSE);
+       filter_add_if_missing("tiff", "Tiff", ".tif;.tiff", FORMAT_CLASS_IMAGE, FALSE);
+       filter_add_if_missing("pnm", "Packed Pixel formats", ".pbm;.pgm;.pnm;.ppm", FORMAT_CLASS_IMAGE, FALSE);
+       filter_add_if_missing("gif", "Graphics Interchange Format", ".gif", FORMAT_CLASS_IMAGE, FALSE);
+       filter_add_if_missing("xbm", "X bitmap", ".xbm", FORMAT_CLASS_IMAGE, FALSE);
+       filter_add_if_missing("xpm", "X pixmap", ".xpm", FORMAT_CLASS_IMAGE, FALSE);
+       filter_add_if_missing("bmp", "Bitmap", ".bmp", FORMAT_CLASS_IMAGE, FALSE);
+       filter_add_if_missing("ico", "Icon file", ".ico;.cur", FORMAT_CLASS_IMAGE, FALSE);
+       filter_add_if_missing("ras", "Raster", ".ras", FORMAT_CLASS_IMAGE, FALSE);
+       filter_add_if_missing("svg", "Scalable Vector Graphics", ".svg", FORMAT_CLASS_IMAGE, FALSE);
        
        /* non-image files that might be desirable to show */
-       filter_add_if_missing("xmp", "XMP sidecar", ".xmp", TRUE);
+       filter_add_if_missing("xmp", "XMP sidecar", ".xmp", FORMAT_CLASS_META, TRUE);
 
        /* These are the raw camera formats with embedded jpeg/exif.
         * (see format_raw.c and/or exiv2.cc)
         */
-       filter_add_if_missing("arw", "Sony raw format", ".arw;.srf;.sr2", TRUE);
-       filter_add_if_missing("crw", "Canon raw format", ".crw;.cr2", TRUE);
-       filter_add_if_missing("kdc", "Kodak raw format", ".kdc;.dcr", TRUE);
-       filter_add_if_missing("raf", "Fujifilm raw format", ".raf", TRUE);
-       filter_add_if_missing("mef", "Mamiya raw format", ".mef;.mos", TRUE);
-       filter_add_if_missing("mrw", "Minolta raw format", ".mrw", TRUE);
-       filter_add_if_missing("nef", "Nikon raw format", ".nef", TRUE);
-       filter_add_if_missing("orf", "Olympus raw format", ".orf", TRUE);
-       filter_add_if_missing("pef", "Pentax raw format", ".pef;.ptx", TRUE);
-       filter_add_if_missing("dng", "Adobe Digital Negative raw format", ".dng", TRUE);
-       filter_add_if_missing("x3f", "Sigma raw format", ".x3f", TRUE);
-       filter_add_if_missing("raw", "Panasonic raw format", ".raw", TRUE);
-       filter_add_if_missing("r3d", "Red raw format", ".r3d", TRUE);
-       filter_add_if_missing("3fr", "Hasselblad raw format", ".3fr", TRUE);
-       filter_add_if_missing("erf", "Epson raw format", ".erf", TRUE);
+       filter_add_if_missing("arw", "Sony raw format", ".arw;.srf;.sr2", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("crw", "Canon raw format", ".crw;.cr2", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("kdc", "Kodak raw format", ".kdc;.dcr", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("raf", "Fujifilm raw format", ".raf", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("mef", "Mamiya raw format", ".mef;.mos", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("mrw", "Minolta raw format", ".mrw", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("nef", "Nikon raw format", ".nef", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("orf", "Olympus raw format", ".orf", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("pef", "Pentax raw format", ".pef;.ptx", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("dng", "Adobe Digital Negative raw format", ".dng", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("x3f", "Sigma raw format", ".x3f", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("raw", "Panasonic raw format", ".raw", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("r3d", "Red raw format", ".r3d", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("3fr", "Hasselblad raw format", ".3fr", FORMAT_CLASS_RAWIMAGE, TRUE);
+       filter_add_if_missing("erf", "Epson raw format", ".erf", FORMAT_CLASS_RAWIMAGE, TRUE);
 }
 
 GList *filter_to_list(const gchar *extensions)
@@ -262,10 +271,17 @@ GList *filter_to_list(const gchar *extensions)
 void filter_rebuild(void)
 {
        GList *work;
+       gint i;
 
-       path_list_free(extension_list);
+       string_list_free(extension_list);
        extension_list = NULL;
 
+       for (i = 0; i < FILE_FORMAT_CLASSES; i++)
+               {
+               string_list_free(file_class_extension_list[i]);
+               file_class_extension_list[i] = NULL;
+               }
+
        work = filter_list;
        while (work)
                {
@@ -280,6 +296,16 @@ void filter_rebuild(void)
 
                        ext = filter_to_list(fe->extensions);
                        if (ext) extension_list = g_list_concat(extension_list, ext);
+                       
+                       if (fe->file_class >= 0 && fe->file_class < FILE_FORMAT_CLASSES)
+                               {
+                               ext = filter_to_list(fe->extensions);
+                               if (ext) file_class_extension_list[fe->file_class] = g_list_concat(file_class_extension_list[fe->file_class], ext);
+                               }
+                       else
+                               {
+                               printf("WARNING: invalid file class %d\n", fe->file_class);
+                               }
                        }
                }
 }
@@ -305,6 +331,32 @@ gint filter_name_exists(const gchar *name)
        return FALSE;
 }
 
+gint filter_file_class(const gchar *name, FileFormatClass file_class)
+{
+       GList *work;
+
+       if (file_class < 0 || file_class >= FILE_FORMAT_CLASSES)
+               {
+               printf("WARNING: invalid file class %d\n", file_class);
+               return FALSE;
+               }
+
+       work = file_class_extension_list[file_class];
+       while (work)
+               {
+               gchar *filter = work->data;
+               gint lf = strlen(filter);
+               gint ln = strlen(name);
+               if (ln >= lf)
+                       {
+                       if (strncasecmp(name + ln - lf, filter, lf) == 0) return TRUE;
+                       }
+               work = work->next;
+               }
+
+       return FALSE;
+}
+
 void filter_write_list(FILE *f)
 {
        GList *work;
@@ -376,7 +428,7 @@ void filter_parse(const gchar *text)
                enabled = FALSE;
                }
 
-       if (key && strlen(key) > 0 && ext) filter_add(key, desc, ext, enabled);
+       if (key && strlen(key) > 0 && ext) filter_add(key, desc, ext, FORMAT_CLASS_UNKNOWN, enabled);
 
        g_free(key);
        g_free(ext);

diff --git a/src/filelist.h b/src/filelist.h
index 3a52089..9d62f25 100644 (file)
--- a/src/filelist.h
+++ b/src/filelist.h
@@ -19,6 +19,7 @@ struct _FilterEntry {
        gchar *key;
        gchar *description;
        gchar *extensions;
+       FileFormatClass file_class;
        gint enabled;
 };
 
@@ -26,14 +27,15 @@ struct _FilterEntry {
 GList *filter_get_list(void);
 void filter_remove_entry(FilterEntry *fe);
 
-void filter_add(const gchar *key, const gchar *description, const gchar *extensions, gint enabled);
-void filter_add_unique(const gchar *description, const gchar *extensions, gint enabled);
+void filter_add(const gchar *key, const gchar *description, const gchar *extensions, FileFormatClass file_class, gint enabled);
+void filter_add_unique(const gchar *description, const gchar *extensions, FileFormatClass file_class, gint enabled);
 void filter_add_defaults(void);
 void filter_reset(void);
 void filter_rebuild(void);
 GList *filter_to_list(const gchar *extensions);
 
 gint filter_name_exists(const gchar *name);
+gint filter_file_class(const gchar *name, FileFormatClass file_class);
 
 void filter_write_list(FILE *f);
 void filter_parse(const gchar *text);

diff --git a/src/preferences.c b/src/preferences.c
index 254b6a2..6334d22 100644 (file)
--- a/src/preferences.c
+++ b/src/preferences.c
@@ -659,7 +659,7 @@ static void filter_set_func(GtkTreeViewColumn *tree_column, GtkCellRenderer *cel
 
 static void filter_add_cb(GtkWidget *widget, gpointer data)
 {
-       filter_add_unique("description", ".new", TRUE);
+       filter_add_unique("description", ".new", FORMAT_CLASS_IMAGE, TRUE);
        filter_store_populate();
 
        /* FIXME: implement the scroll to/select row stuff for tree view */

diff --git a/src/typedefs.h b/src/typedefs.h
index fb8d148..891ce2c 100644 (file)
--- a/src/typedefs.h
+++ b/src/typedefs.h
@@ -88,6 +88,14 @@ typedef enum {
        STM_MODE_TOGGLE
 } SelectionToMarkMode;
 
+typedef enum {
+       FORMAT_CLASS_UNKNOWN,
+       FORMAT_CLASS_IMAGE,
+       FORMAT_CLASS_RAWIMAGE,
+       FORMAT_CLASS_META,
+       FILE_FORMAT_CLASSES
+} FileFormatClass;
+
 
 #define MAX_SPLIT_IMAGES 4