GNOME.org
 

[rhythmbox] metadata: add to python bindings (bug #594132)

commit 1f7daa51048c5da5e9b7479352489a1388182df3
Author: Jonathan Matthew <jonathan d14n org>
Date:   Sun Jan 24 15:04:33 2010 +1000

    metadata: add to python bindings (bug #594132)
    
    This involves converting RBMetaDataField into a GEnum.  A couple of the
    metadata functions also required overrides to deal with GValues.

 bindings/python/Makefile.am   |    1 +
 bindings/python/rb.defs       |  197 +++++++++++++++++++++++++++++++++++++++++
 bindings/python/rb.override   |   62 +++++++++++++-
 metadata/rb-metadata-common.c |  178 ++++++++++++++++++++++++++-----------
 metadata/rb-metadata.h        |    6 ++
 5 files changed, 393 insertions(+), 51 deletions(-)
---
diff --git a/bindings/python/Makefile.am b/bindings/python/Makefile.am
index fca0203..ffc925c 100644
--- a/bindings/python/Makefile.am
+++ b/bindings/python/Makefile.am
@@ -53,6 +53,7 @@ BINDING_HEADERS_SRCDIR_IN = \
 	lib/rb-string-value-map.h		\
 	lib/rb-cut-and-paste-code.h		\
 	lib/rb-file-helpers.h			\
+	metadata/rb-metadata.h			\
 	rhythmdb/rhythmdb.h			\
 	rhythmdb/rhythmdb-property-model.h	\
 	rhythmdb/rhythmdb-query-model.h		\
diff --git a/bindings/python/rb.defs b/bindings/python/rb.defs
index 400d755..9121680 100644
--- a/bindings/python/rb.defs
+++ b/bindings/python/rb.defs
@@ -165,6 +165,14 @@
   (gtype-id "RB_TYPE_SOURCE_SEARCH_BASIC")
 )
 
+(define-object MetaData
+  (in-module "RB")
+  (parent "GObject")
+  (c-name "RBMetaData")
+  (gtype-id "RB_TYPE_METADATA")
+)
+
+
 ;; Enumerations and flags ...
 
 (define-enum ShellPlayerError
@@ -285,6 +293,62 @@
   )
 )
 
+(define-enum MetaDataField
+  (in-module "RB")
+  (c-name "RBMetaDataField")
+  (gtype-id "RB_TYPE_METADATA_FIELD")
+  (values
+    '("title" "RB_METADATA_FIELD_TITLE")
+    '("artist" "RB_METADATA_FIELD_ARTIST")
+    '("album" "RB_METADATA_FIELD_ALBUM")
+    '("date" "RB_METADATA_FIELD_DATE")
+    '("genre" "RB_METADATA_FIELD_GENRE")
+    '("comment" "RB_METADATA_FIELD_COMMENT")
+    '("track-number" "RB_METADATA_FIELD_TRACK_NUMBER")
+    '("max-track-number" "RB_METADATA_FIELD_MAX_TRACK_NUMBER")
+    '("disc-number" "RB_METADATA_FIELD_DISC_NUMBER")
+    '("max-disc-number" "RB_METADATA_FIELD_MAX_DISC_NUMBER")
+    '("description" "RB_METADATA_FIELD_DESCRIPTION")
+    '("version" "RB_METADATA_FIELD_VERSION")
+    '("isrc" "RB_METADATA_FIELD_ISRC")
+    '("organization" "RB_METADATA_FIELD_ORGANIZATION")
+    '("copyright" "RB_METADATA_FIELD_COPYRIGHT")
+    '("contact" "RB_METADATA_FIELD_CONTACT")
+    '("license" "RB_METADATA_FIELD_LICENSE")
+    '("performer" "RB_METADATA_FIELD_PERFORMER")
+    '("duration" "RB_METADATA_FIELD_DURATION")
+    '("codec" "RB_METADATA_FIELD_CODEC")
+    '("bitrate" "RB_METADATA_FIELD_BITRATE")
+    '("track-gain" "RB_METADATA_FIELD_TRACK_GAIN")
+    '("track-peak" "RB_METADATA_FIELD_TRACK_PEAK")
+    '("album-gain" "RB_METADATA_FIELD_ALBUM_GAIN")
+    '("album-peak" "RB_METADATA_FIELD_ALBUM_PEAK")
+    '("language-code" "RB_METADATA_FIELD_LANGUAGE_CODE")
+    '("musicbrainz-trackid" "RB_METADATA_FIELD_MUSICBRAINZ_TRACKID")
+    '("musicbrainz-artistid" "RB_METADATA_FIELD_MUSICBRAINZ_ARTISTID")
+    '("musicbrainz-albumid" "RB_METADATA_FIELD_MUSICBRAINZ_ALBUMID")
+    '("musicbrainz-albumartistid" "RB_METADATA_FIELD_MUSICBRAINZ_ALBUMARTISTID")
+    '("artist-sortname" "RB_METADATA_FIELD_ARTIST_SORTNAME")
+    '("album-sortname" "RB_METADATA_FIELD_ALBUM_SORTNAME")
+    '("last" "RB_METADATA_FIELD_LAST")
+  )
+)
+
+(define-enum MetaDataError
+  (in-module "RB")
+  (c-name "RBMetaDataError")
+  (gtype-id "RB_TYPE_METADATA_ERROR")
+  (values
+    '("io" "RB_METADATA_ERROR_IO")
+    '("missing-plugin" "RB_METADATA_ERROR_MISSING_PLUGIN")
+    '("unrecognized" "RB_METADATA_ERROR_UNRECOGNIZED")
+    '("unsupported" "RB_METADATA_ERROR_UNSUPPORTED")
+    '("general" "RB_METADATA_ERROR_GENERAL")
+    '("internal" "RB_METADATA_ERROR_INTERNAL")
+    '("empty-file" "RB_METADATA_ERROR_EMPTY_FILE")
+  )
+)
+
 ;; From ../../plugins/rb-plugin.h
 
 (define-function rb_plugin_get_type
@@ -2638,3 +2702,136 @@
     '("int" "n_actions")
   )
 )
+
+;; From rb-metadata.h
+
+(define-function rb_metadata_error_quark
+  (c-name "rb_metadata_error_quark")
+  (return-type "GQuark")
+)
+
+(define-function rb_metadata_get_type
+  (c-name "rb_metadata_get_type")
+  (return-type "GType")
+)
+
+(define-function rb_metadata_field_get_type
+  (c-name "rb_metadata_field_get_type")
+  (return-type "GType")
+)
+
+(define-function rb_metadata_get_field_type
+  (c-name "rb_metadata_get_field_type")
+  (return-type "GType")
+  (parameters
+    '("RBMetaDataField" "field")
+  )
+)
+
+(define-function rb_metadata_get_field_name
+  (c-name "rb_metadata_get_field_name")
+  (return-type "const-char*")
+  (parameters
+    '("RBMetaDataField" "field")
+  )
+)
+
+(define-function rb_metadata_new
+  (c-name "rb_metadata_new")
+  (is-constructor-of "RbMetadata")
+  (return-type "RBMetaData*")
+)
+
+(define-method can_save
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_can_save")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "mimetype")
+  )
+)
+
+(define-method get_saveable_types
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_get_saveable_types")
+  (return-type "char**")
+)
+
+(define-method load
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_load")
+  (return-type "none")
+  (parameters
+    '("const-char*" "uri")
+    '("GError**" "error")
+  )
+)
+
+(define-method save
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_save")
+  (return-type "none")
+  (parameters
+    '("GError**" "error")
+  )
+)
+
+(define-method get_mime
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_get_mime")
+  (return-type "const-char*")
+)
+
+(define-method has_missing_plugins
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_has_missing_plugins")
+  (return-type "gboolean")
+)
+
+(define-method get_missing_plugins
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_get_missing_plugins")
+  (return-type "gboolean")
+  (parameters
+    '("char***" "missing_plugins")
+    '("char***" "plugin_descriptions")
+  )
+)
+
+(define-method has_audio
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_has_audio")
+  (return-type "gboolean")
+)
+
+(define-method has_video
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_has_video")
+  (return-type "gboolean")
+)
+
+(define-method has_other_data
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_has_other_data")
+  (return-type "gboolean")
+)
+
+(define-method get
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_get")
+  (return-type "gboolean")
+  (parameters
+    '("RBMetaDataField" "field")
+    '("GValue*" "val")
+  )
+)
+
+(define-method set
+  (of-object "RBMetaData")
+  (c-name "rb_metadata_set")
+  (return-type "gboolean")
+  (parameters
+    '("RBMetaDataField" "field")
+    '("const-GValue*" "val")
+  )
+)
diff --git a/bindings/python/rb.override b/bindings/python/rb.override
index 358ff06..1f0f595 100644
--- a/bindings/python/rb.override
+++ b/bindings/python/rb.override
@@ -18,6 +18,7 @@ headers
 #include "rb-entry-view.h"
 #include "rb-file-helpers.h"
 #include "rb-library-browser.h"
+#include "rb-metadata.h"
 #include "rb-playlist-source.h"
 #include "rb-player.h"
 #include "rb-player-gst-filter.h"
@@ -1461,7 +1462,6 @@ _wrap_rb_streaming_source_get_progress(PyGObject *self)
     g_free (progress_text);
     return tuple;
 }
-
 %%
 override RBSource__proxy_do_impl_get_delete_action
 static char *
@@ -1545,3 +1545,63 @@ _wrap_RBSource__do_impl_get_delete_action(PyObject *cls, PyObject *args, PyObjec
     g_free (key);
     return tuple;
 }
+%%
+override rb_metadata_get kwargs
+static PyObject *
+_wrap_rb_metadata_get(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+	static char *kwlist[] = { "field", NULL };
+	PyObject *py_field = NULL;
+	RBMetaData *metadata;
+	int field;
+	GValue value = {0,};
+	PyObject *ret;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:RBMetaData.get", kwlist, &py_field))
+		return NULL;
+	if (pyg_enum_get_value(RB_TYPE_METADATA_FIELD, py_field, &field))
+		return NULL;
+
+	metadata = RB_METADATA (self->obj);
+	g_value_init (&value, rb_metadata_get_field_type ((RBMetaDataField)field));
+	rb_metadata_get (metadata, (RBMetaDataField)field, &value);
+	ret = pyg_value_as_pyobject (&value, TRUE);
+	g_value_unset (&value);
+	if (ret)
+		return ret;
+	Py_RETURN_NONE;
+}
+%%
+override rb_metadata_set kwargs
+static PyObject *
+_wrap_rb_metadata_set(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+	static char *kwlist[] = { "field", "value", NULL };
+	PyObject *py_field = NULL;
+	PyObject *py_value = NULL;
+	int field;
+	GValue value = {0,};
+	GType field_type;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RBMetaData.set", kwlist, &py_field, &py_value))
+		return NULL;
+	if (pyg_enum_get_value(RB_TYPE_METADATA_FIELD, py_field, &field))
+		return NULL;
+
+	field_type = rb_metadata_get_field_type ((RBMetaDataField)field);
+	g_value_init(&value, field_type);
+	if (pyg_value_from_pyobject(&value, py_value) < 0) {
+		char *s;
+
+		s = g_strdup_printf ("could not convert argument from type '%s' (%d) to correct type '%s'",
+					 g_type_name (pyg_type_from_object (py_value)),
+					 (int)pyg_type_from_object (py_value),
+					 g_type_name (field_type));
+		PyErr_SetString(PyExc_TypeError, s);
+		g_free (s);
+		return NULL;
+	}
+	rb_metadata_set (RB_METADATA (self->obj), (RBMetaDataField)field, &value);
+	g_value_unset (&value);
+	Py_RETURN_NONE;
+}
diff --git a/metadata/rb-metadata-common.c b/metadata/rb-metadata-common.c
index 5c39dfa..4f39d02 100644
--- a/metadata/rb-metadata-common.c
+++ b/metadata/rb-metadata-common.c
@@ -30,52 +30,6 @@
 #include "rb-metadata.h"
 #include "rb-debug.h"
 
-struct RBMetaDataFieldInfo {
-	GType type;
-	const char *name;
-};
-
-/*
- * Note: the field names are the same as those used by GStreamer.  We
- * could have just use the GST_TAG_X defines, but that would suck if we
- * ever got a non-GStreamer metadata backend.
- */
-static struct RBMetaDataFieldInfo field_info[RB_METADATA_FIELD_LAST] = {
-	/* RB_METADATA_FIELD_TITLE */ 			{ G_TYPE_STRING, "title" },
-	/* RB_METADATA_FIELD_ARTIST */ 			{ G_TYPE_STRING, "artist" },
-	/* RB_METADATA_FIELD_ALBUM */ 			{ G_TYPE_STRING, "album" },
-	/* RB_METADATA_FIELD_DATE */ 			{ G_TYPE_ULONG, "date" },
-	/* RB_METADATA_FIELD_GENRE */ 			{ G_TYPE_STRING, "genre" },
-	/* RB_METADATA_FIELD_COMMENT */			{ G_TYPE_STRING, "comment" },
-	/* RB_METADATA_FIELD_TRACK_NUMBER */		{ G_TYPE_ULONG, "track-number" },
-	/* RB_METADATA_FIELD_MAX_TRACK_NUMBER */	{ G_TYPE_ULONG, "track-count" },
-	/* RB_METADATA_FIELD_DISC_NUMBER */ 		{ G_TYPE_ULONG, "album-disc-number" },
-	/* RB_METADATA_FIELD_MAX_DISC_NUMBER */ 	{ G_TYPE_ULONG, "album-disc-count" },
-	/* RB_METADATA_FIELD_DESCRIPTION */ 		{ G_TYPE_STRING, "description" },
-	/* RB_METADATA_FIELD_VERSION */ 		{ G_TYPE_STRING, "version" },
-	/* RB_METADATA_FIELD_IRSC */	 		{ G_TYPE_STRING, "isrc" },
-	/* RB_METADATA_FIELD_ORGANIZATION */ 		{ G_TYPE_STRING, "organization" },
-	/* RB_METADATA_FIELD_COPYRIGHT */ 		{ G_TYPE_STRING, "copyright" },
-	/* RB_METADATA_FIELD_CONTACT */ 		{ G_TYPE_STRING, "contact" },
-	/* RB_METADATA_FIELD_LICENSE */ 		{ G_TYPE_STRING, "license" },
-	/* RB_METADATA_FIELD_PERFORMER */ 		{ G_TYPE_STRING, "performer" },
-	/* RB_METADATA_FIELD_DURATION */ 		{ G_TYPE_ULONG, "duration" },
-	/* RB_METADATA_FIELD_CODEC */	 		{ G_TYPE_STRING, "codec" },
-	/* RB_METADATA_FIELD_BITRATE */ 		{ G_TYPE_ULONG, "bitrate" },
-	/* RB_METADATA_FIELD_TRACK_GAIN */ 		{ G_TYPE_DOUBLE, "replaygain-track-gain" },
-	/* RB_METADATA_FIELD_TRACK_PEAK */ 		{ G_TYPE_DOUBLE, "replaygain-track-peak" },
-	/* RB_METADATA_FIELD_ALBUM_GAIN */ 		{ G_TYPE_DOUBLE, "replaygain-album-gain" },
-	/* RB_METADATA_FIELD_ALBUM_PEAK */ 		{ G_TYPE_DOUBLE, "replaygain-album-peak" },
-	/* RB_METADATA_FIELD_LANGUAGE_CODE */		{ G_TYPE_STRING, "language-code" },
-	/* RB_METADATA_FIELD_MUSICBRAINZ_TRACKID */	{ G_TYPE_STRING, "musicbrainz-trackid" },
-	/* RB_METADATA_FIELD_MUSICBRAINZ_ARTISTID */	{ G_TYPE_STRING, "musicbrainz-artistid" },
-	/* RB_METADATA_FIELD_MUSICBRAINZ_ALBUMID */	{ G_TYPE_STRING, "musicbrainz-albumid" },
-	/* RB_METADATA_FIELD_MUSICBRAINZ_ALBUMARTISTID */ { G_TYPE_STRING, "musicbrainz-albumartistid" },
-	/* RB_METADATA_FIELD_ARTIST_SORTNAME */         { G_TYPE_STRING, "musicbrainz-sortname" },
-	/* RB_METADATA_FIELD_ALBUM_SORTNAME */         { G_TYPE_STRING, "album-sortname" },
-
-};
-
 /**
  * RBMetaDataField:
  * @RB_METADATA_FIELD_TITLE: Title of the recording
@@ -123,8 +77,48 @@ static struct RBMetaDataFieldInfo field_info[RB_METADATA_FIELD_LAST] = {
 GType
 rb_metadata_get_field_type (RBMetaDataField field)
 {
-	g_assert (field >= 0 && field < RB_METADATA_FIELD_LAST);
-	return field_info[field].type;
+	switch (field) {
+	case RB_METADATA_FIELD_TITLE:
+	case RB_METADATA_FIELD_ARTIST:
+	case RB_METADATA_FIELD_ALBUM:
+	case RB_METADATA_FIELD_GENRE:
+	case RB_METADATA_FIELD_COMMENT:
+	case RB_METADATA_FIELD_DESCRIPTION:
+	case RB_METADATA_FIELD_VERSION:
+	case RB_METADATA_FIELD_ISRC:
+	case RB_METADATA_FIELD_ORGANIZATION:
+	case RB_METADATA_FIELD_COPYRIGHT:
+	case RB_METADATA_FIELD_CONTACT:
+	case RB_METADATA_FIELD_LICENSE:
+	case RB_METADATA_FIELD_PERFORMER:
+	case RB_METADATA_FIELD_CODEC:
+	case RB_METADATA_FIELD_LANGUAGE_CODE:
+	case RB_METADATA_FIELD_MUSICBRAINZ_TRACKID:
+	case RB_METADATA_FIELD_MUSICBRAINZ_ARTISTID:
+	case RB_METADATA_FIELD_MUSICBRAINZ_ALBUMID:
+	case RB_METADATA_FIELD_MUSICBRAINZ_ALBUMARTISTID:
+	case RB_METADATA_FIELD_ARTIST_SORTNAME:
+	case RB_METADATA_FIELD_ALBUM_SORTNAME:
+		return G_TYPE_STRING;
+
+	case RB_METADATA_FIELD_DATE:
+	case RB_METADATA_FIELD_TRACK_NUMBER:
+	case RB_METADATA_FIELD_MAX_TRACK_NUMBER:
+	case RB_METADATA_FIELD_DISC_NUMBER:
+	case RB_METADATA_FIELD_MAX_DISC_NUMBER:
+	case RB_METADATA_FIELD_DURATION:
+	case RB_METADATA_FIELD_BITRATE:
+		return G_TYPE_ULONG;
+
+	case RB_METADATA_FIELD_TRACK_GAIN:
+	case RB_METADATA_FIELD_TRACK_PEAK:
+	case RB_METADATA_FIELD_ALBUM_GAIN:
+	case RB_METADATA_FIELD_ALBUM_PEAK:
+		return G_TYPE_DOUBLE;
+
+	default:
+		g_assert_not_reached ();
+	}
 }
 
 /**
@@ -136,8 +130,11 @@ rb_metadata_get_field_type (RBMetaDataField field)
 const char *
 rb_metadata_get_field_name (RBMetaDataField field)
 {
-	g_assert (field >= 0 && field < RB_METADATA_FIELD_LAST);
-	return field_info[field].name;
+	GEnumClass *klass;
+
+	klass = g_type_class_ref (RB_TYPE_METADATA_FIELD);
+	g_assert (field >= 0 && field < klass->n_values);
+	return klass->values[field].value_nick;
 }
 
 GQuark
@@ -149,3 +146,84 @@ rb_metadata_error_quark (void)
 
 	return quark;
 }
+
+
+#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
+
+
+GType
+rb_metadata_field_get_type (void)
+{
+	static GType etype = 0;
+
+	if (etype == 0) {
+		static const GEnumValue values[] =
+		{
+			/* Note: field names are the GStreamer tag names.
+			 * We could have just used the GST_TAG_X defines, but that
+			 * would suck if we ever got a non-GStreamer metadata backend.
+			 *
+			 * maybe pack the field types in here too, like RhythmDBPropType?
+			 */
+			ENUM_ENTRY (RB_METADATA_FIELD_TITLE, "title"),
+			ENUM_ENTRY (RB_METADATA_FIELD_ARTIST, "artist"),
+			ENUM_ENTRY (RB_METADATA_FIELD_ALBUM, "album"),
+			ENUM_ENTRY (RB_METADATA_FIELD_DATE, "date"),
+			ENUM_ENTRY (RB_METADATA_FIELD_GENRE, "genre"),
+			ENUM_ENTRY (RB_METADATA_FIELD_COMMENT, "comment"),
+			ENUM_ENTRY (RB_METADATA_FIELD_TRACK_NUMBER, "track-number"),
+			ENUM_ENTRY (RB_METADATA_FIELD_MAX_TRACK_NUMBER, "track-count"),
+			ENUM_ENTRY (RB_METADATA_FIELD_DISC_NUMBER, "album-disc-number"),
+			ENUM_ENTRY (RB_METADATA_FIELD_MAX_DISC_NUMBER, "album-disc-count"),
+			ENUM_ENTRY (RB_METADATA_FIELD_DESCRIPTION, "description"),
+			ENUM_ENTRY (RB_METADATA_FIELD_VERSION, "version"),
+			ENUM_ENTRY (RB_METADATA_FIELD_ISRC, "isrc"),
+			ENUM_ENTRY (RB_METADATA_FIELD_ORGANIZATION, "organization"),
+			ENUM_ENTRY (RB_METADATA_FIELD_COPYRIGHT, "copyright"),
+			ENUM_ENTRY (RB_METADATA_FIELD_CONTACT, "contact"),
+			ENUM_ENTRY (RB_METADATA_FIELD_LICENSE, "license"),
+			ENUM_ENTRY (RB_METADATA_FIELD_PERFORMER, "performer"),
+			ENUM_ENTRY (RB_METADATA_FIELD_DURATION, "duration"),
+			ENUM_ENTRY (RB_METADATA_FIELD_CODEC, "codec"),
+			ENUM_ENTRY (RB_METADATA_FIELD_BITRATE, "bitrate"),
+			ENUM_ENTRY (RB_METADATA_FIELD_TRACK_GAIN, "replaygain-track-gain"),
+			ENUM_ENTRY (RB_METADATA_FIELD_TRACK_PEAK, "replaygain-track-peak"),
+			ENUM_ENTRY (RB_METADATA_FIELD_ALBUM_GAIN, "replaygain-album-gain"),
+			ENUM_ENTRY (RB_METADATA_FIELD_ALBUM_PEAK, "replaygain-album-peak"),
+			ENUM_ENTRY (RB_METADATA_FIELD_LANGUAGE_CODE, "language-code"),
+			ENUM_ENTRY (RB_METADATA_FIELD_MUSICBRAINZ_TRACKID, "musicbrainz-trackid"),
+			ENUM_ENTRY (RB_METADATA_FIELD_MUSICBRAINZ_ARTISTID, "musicbrainz-artistid"),
+			ENUM_ENTRY (RB_METADATA_FIELD_MUSICBRAINZ_ALBUMID, "musicbrainz-albumid"),
+			ENUM_ENTRY (RB_METADATA_FIELD_MUSICBRAINZ_ALBUMARTISTID, "musicbrainz-albumartistid"),
+			ENUM_ENTRY (RB_METADATA_FIELD_ARTIST_SORTNAME, "musicbrainz-sortname"),
+			ENUM_ENTRY (RB_METADATA_FIELD_ALBUM_SORTNAME, "album-sortname"),
+			{ 0, 0, 0 }
+		};
+		etype = g_enum_register_static ("RBMetadataFieldType", values);
+	}
+
+	return etype;
+}
+
+GType
+rb_metadata_error_get_type (void)
+{
+	static GType etype = 0;
+
+	if (etype == 0) {
+		static const GEnumValue values[] =
+		{
+			ENUM_ENTRY(RB_METADATA_ERROR_IO, "IO error"),
+			ENUM_ENTRY(RB_METADATA_ERROR_MISSING_PLUGIN, "Missing plugins required to read the file"),
+			ENUM_ENTRY(RB_METADATA_ERROR_UNRECOGNIZED, "Unable to identify the file type"),
+			ENUM_ENTRY(RB_METADATA_ERROR_UNSUPPORTED, "Unsupported file type"),
+			ENUM_ENTRY(RB_METADATA_ERROR_GENERAL, "General error"),
+			ENUM_ENTRY(RB_METADATA_ERROR_INTERNAL, "Internal error"),
+			ENUM_ENTRY(RB_METADATA_ERROR_EMPTY_FILE, "Empty file"),
+			{ 0, 0, 0 }
+		};
+		etype = g_enum_register_static ("RBMetadataErrorType", values);
+	}
+
+	return etype;
+}
diff --git a/metadata/rb-metadata.h b/metadata/rb-metadata.h
index 9918048..bce8858 100644
--- a/metadata/rb-metadata.h
+++ b/metadata/rb-metadata.h
@@ -70,6 +70,8 @@ typedef enum
 	RB_METADATA_FIELD_LAST			   /* nothing */
 } RBMetaDataField;
 
+#define RB_TYPE_METADATA_FIELD (rb_metadata_field_get_type ())
+
 typedef enum
 {
 	RB_METADATA_ERROR_IO,
@@ -82,6 +84,7 @@ typedef enum
 } RBMetaDataError;
 
 #define RB_METADATA_ERROR rb_metadata_error_quark ()
+#define RB_TYPE_METADATA_ERROR (rb_metadata_error_get_type ())
 
 GQuark rb_metadata_error_quark (void);
 
@@ -111,6 +114,9 @@ struct _RBMetaDataClass
 
 GType		rb_metadata_get_type	(void);
 
+GType		rb_metadata_field_get_type (void);
+GType		rb_metadata_error_get_type (void);
+
 GType		rb_metadata_get_field_type (RBMetaDataField field);
 
 const char *	rb_metadata_get_field_name (RBMetaDataField field);
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]