GNOME.org
 

brasero r674 - trunk/src/plugins/checksum

Author: philippr
Date: Fri Mar 14 08:40:59 2008
New Revision: 674
URL: http://svn.gnome.org/viewvc/brasero?rev=674&view=rev

Log:
Same as before for the function/object names

Modified:
   trunk/src/plugins/checksum/burn-checksum-files.c
   trunk/src/plugins/checksum/burn-checksum-files.h
   trunk/src/plugins/checksum/burn-checksum-image.c
   trunk/src/plugins/checksum/burn-checksum-image.h

Modified: trunk/src/plugins/checksum/burn-checksum-files.c
==============================================================================
--- trunk/src/plugins/checksum/burn-checksum-files.c	(original)
+++ trunk/src/plugins/checksum/burn-checksum-files.c	Fri Mar 14 08:40:59 2008
@@ -48,9 +48,9 @@
 #include "burn-drive.h"
 #include "burn-volume-obj.h"
 
-BRASERO_PLUGIN_BOILERPLATE (BraseroMd5sumFile, brasero_md5sum_file, BRASERO_TYPE_JOB, BraseroJob);
+BRASERO_PLUGIN_BOILERPLATE (BraseroChecksumFiles, brasero_checksum_files, BRASERO_TYPE_JOB, BraseroJob);
 
-struct _BraseroMd5sumFilePrivate {
+struct _BraseroChecksumFilesPrivate {
 	/* the path to read from when we check */
 	gchar *sums_path;
 	BraseroChecksumType checksum_type;
@@ -66,9 +66,9 @@
 
 	guint cancel;
 };
-typedef struct _BraseroMd5sumFilePrivate BraseroMd5sumFilePrivate;
+typedef struct _BraseroChecksumFilesPrivate BraseroChecksumFilesPrivate;
 
-#define BRASERO_MD5SUM_FILE_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), BRASERO_TYPE_MD5SUM_FILE, BraseroMd5sumFilePrivate))
+#define BRASERO_CHECKSUM_FILES_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), BRASERO_TYPE_CHECKSUM_FILES, BraseroChecksumFilesPrivate))
 
 #define BLOCK_SIZE			64
 #define GCONF_KEY_CHECKSUM_TYPE		"/apps/brasero/config/checksum_files"
@@ -76,19 +76,19 @@
 static BraseroJobClass *parent_class = NULL;
 
 static BraseroBurnResult
-brasero_md5sum_file_get_file_checksum (BraseroMd5sumFile *self,
-				       GChecksumType type,
-				       const gchar *path,
-				       gchar **checksum_string,
-				       GError **error)
+brasero_checksum_files_get_file_checksum (BraseroChecksumFiles *self,
+					  GChecksumType type,
+					  const gchar *path,
+					  gchar **checksum_string,
+					  GError **error)
 {
-	BraseroMd5sumFilePrivate *priv;
+	BraseroChecksumFilesPrivate *priv;
 	guchar buffer [BLOCK_SIZE];
 	GChecksum *checksum;
 	gint read_bytes;
 	FILE *file;
 
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (self);
 
 	file = fopen (path, "r");
 	if (!file) {
@@ -132,25 +132,25 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_file_add_file_checksum (BraseroMd5sumFile *self,
-				       const gchar *path,
-				       GChecksumType checksum_type,
-				       const gchar *graft_path,
-				       GError **error)
+brasero_checksum_files_add_file_checksum (BraseroChecksumFiles *self,
+					  const gchar *path,
+					  GChecksumType checksum_type,
+					  const gchar *graft_path,
+					  GError **error)
 {
 	BraseroBurnResult result = BRASERO_BURN_OK;
-	BraseroMd5sumFilePrivate *priv;
+	BraseroChecksumFilesPrivate *priv;
 	gchar *checksum_string = NULL;
 	gint written;
 
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (self);
 
 	/* write to the file */
-	result = brasero_md5sum_file_get_file_checksum (self,
-							checksum_type,
-							path,
-							&checksum_string,
-							error);
+	result = brasero_checksum_files_get_file_checksum (self,
+							   checksum_type,
+							   path,
+							   &checksum_string,
+							   error);
 	if (result != BRASERO_BURN_OK)
 		return BRASERO_BURN_ERR;
 
@@ -201,20 +201,20 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_file_explore_directory (BraseroMd5sumFile *self,
-				       GChecksumType checksum_type,
-				       gint64 file_nb,
-				       const gchar *directory,
-				       const gchar *disc_path,
-				       GHashTable *excludedH,
-				       GError **error)
+brasero_checksum_files_explore_directory (BraseroChecksumFiles *self,
+					  GChecksumType checksum_type,
+					  gint64 file_nb,
+					  const gchar *directory,
+					  const gchar *disc_path,
+					  GHashTable *excludedH,
+					  GError **error)
 {
 	BraseroBurnResult result = BRASERO_BURN_OK;
-	BraseroMd5sumFilePrivate *priv;
+	BraseroChecksumFilesPrivate *priv;
 	const gchar *name;
 	GDir *dir;
 
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (self);
 
 	dir = g_dir_open (directory, 0, error);
 	if (!dir || *error)
@@ -237,13 +237,13 @@
 
 		graft_path = g_build_path (G_DIR_SEPARATOR_S, disc_path, name, NULL);
 		if (g_file_test (path, G_FILE_TEST_IS_DIR)) {
-			result = brasero_md5sum_file_explore_directory (self,
-									checksum_type,
-									file_nb,
-									path,
-									graft_path,
-									excludedH,
-									error);
+			result = brasero_checksum_files_explore_directory (self,
+									   checksum_type,
+									   file_nb,
+									   path,
+									   graft_path,
+									   excludedH,
+									   error);
 			g_free (path);
 			g_free (graft_path);
 
@@ -253,11 +253,11 @@
 			continue;
 		}
 
-		result = brasero_md5sum_file_add_file_checksum (self,
-								path,
-								checksum_type,
-								graft_path,
-								error);
+		result = brasero_checksum_files_add_file_checksum (self,
+								   path,
+								   checksum_type,
+								   graft_path,
+								   error);
 		g_free (graft_path);
 		g_free (path);
 
@@ -279,7 +279,7 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_file_create_checksum (BraseroMd5sumFile *self,
+brasero_checksum_files_create_checksum (BraseroChecksumFiles *self,
 				     GError **error)
 {
 	GSList *iter;
@@ -288,11 +288,11 @@
 	GConfClient *client;
 	GHashTable *excludedH;
 	GChecksumType gchecksum_type;
-	BraseroMd5sumFilePrivate *priv;
+	BraseroChecksumFilesPrivate *priv;
 	BraseroChecksumType checksum_type;
 	BraseroBurnResult result = BRASERO_BURN_OK;
 
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (self);
 
 	/* get the checksum type */
 	client = gconf_client_get_default ();
@@ -406,19 +406,19 @@
 		graft_path = graft->path;
 
 		if (g_file_test (path, G_FILE_TEST_IS_DIR))
-			result = brasero_md5sum_file_explore_directory (self,
-									gchecksum_type,
-									file_nb,
-									path,
-									graft_path,
-									excludedH,
-									error);
+			result = brasero_checksum_files_explore_directory (self,
+									   gchecksum_type,
+									   file_nb,
+									   path,
+									   graft_path,
+									   excludedH,
+									   error);
 		else {
-			result = brasero_md5sum_file_add_file_checksum (self,
-									path,
-									gchecksum_type,
-									graft_path,
-									error);
+			result = brasero_checksum_files_add_file_checksum (self,
+									   path,
+									   gchecksum_type,
+									   graft_path,
+									   error);
 			priv->file_num ++;
 			brasero_job_set_progress (BRASERO_JOB (self),
 						  (gdouble) priv->file_num /
@@ -440,9 +440,9 @@
 }
 
 static gint
-brasero_md5sum_file_get_line_num (BraseroMd5sumFile *self,
-				  FILE *file,
-				  GError **error)
+brasero_checksum_files_get_line_num (BraseroChecksumFiles *self,
+				     FILE *file,
+				     GError **error)
 {
 	gint c;
 	gint num = 0;
@@ -465,9 +465,9 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_file_check_files (BraseroMd5sumFile *self,
-				 BraseroChecksumType checksum_type,
-				 GError **error)
+brasero_checksum_files_check_files (BraseroChecksumFiles *self,
+				    BraseroChecksumType checksum_type,
+				    GError **error)
 {
 	gchar *root;
 	gchar *path;
@@ -481,11 +481,11 @@
 	BraseroMedium *medium;
 	gboolean has_wrongsums;
 	GChecksumType gchecksum_type;
-	BraseroMd5sumFilePrivate *priv;
+	BraseroChecksumFilesPrivate *priv;
 	gchar filename [MAXPATHLEN + 1];
 	BraseroBurnResult result = BRASERO_BURN_OK;
 
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (self);
 
 	has_wrongsums = FALSE;
 
@@ -514,7 +514,7 @@
 	}
 
 	/* we need to get the number of files at this time and rewind */
-	file_nb = brasero_md5sum_file_get_line_num (self, file, error);
+	file_nb = brasero_checksum_files_get_line_num (self, file, error);
 	if (file_nb < 1) {
 		g_set_error (error,
 			     BRASERO_BURN_ERROR,
@@ -622,11 +622,11 @@
 
 		filename [i] = 0;
 		checksum_real = NULL;
-		result = brasero_md5sum_file_get_file_checksum (self,
-								gchecksum_type,
-								filename,
-								&checksum_real,
-								error);
+		result = brasero_checksum_files_get_file_checksum (self,
+								   gchecksum_type,
+								   filename,
+								   &checksum_real,
+								   error);
 		if (result == BRASERO_BURN_RETRY)
 			continue;
 
@@ -667,26 +667,26 @@
 	return BRASERO_BURN_OK;
 }
 
-struct _BraseroMd5sumFileThreadCtx {
-	BraseroMd5sumFile *sum;
+struct _BraseroChecksumFilesThreadCtx {
+	BraseroChecksumFiles *sum;
 	BraseroBurnResult result;
 	GError *error;
 };
-typedef struct _BraseroMd5sumFileThreadCtx BraseroMd5sumFileThreadCtx;
+typedef struct _BraseroChecksumFilesThreadCtx BraseroChecksumFilesThreadCtx;
 
 static gboolean
-brasero_md5sum_file_end (gpointer data)
+brasero_checksum_files_end (gpointer data)
 {
 	BraseroTrack *track;
 	BraseroTrackType input;
-	BraseroMd5sumFile *self;
+	BraseroChecksumFiles *self;
 	BraseroJobAction action;
-	BraseroMd5sumFilePrivate *priv;
-	BraseroMd5sumFileThreadCtx *ctx;
+	BraseroChecksumFilesPrivate *priv;
+	BraseroChecksumFilesThreadCtx *ctx;
 
 	ctx = data;
 	self = ctx->sum;
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (self);
 
 	/* NOTE ctx/data is destroyed in its own callback */
 	priv->end_id = 0;
@@ -783,9 +783,9 @@
 }
 
 static void
-brasero_md5sum_file_destroy (gpointer data)
+brasero_checksum_files_destroy (gpointer data)
 {
-	BraseroMd5sumFileThreadCtx *ctx;
+	BraseroChecksumFilesThreadCtx *ctx;
 
 	ctx = data;
 	if (ctx->error) {
@@ -797,17 +797,17 @@
 }
 
 static gpointer
-brasero_md5sum_file_thread (gpointer data)
+brasero_checksum_files_thread (gpointer data)
 {
-	BraseroMd5sumFile *self;
+	BraseroChecksumFiles *self;
 	GError *error = NULL;
 	BraseroJobAction action;
-	BraseroMd5sumFilePrivate *priv;
-	BraseroMd5sumFileThreadCtx *ctx;
+	BraseroChecksumFilesPrivate *priv;
+	BraseroChecksumFilesThreadCtx *ctx;
 	BraseroBurnResult result = BRASERO_BURN_NOT_SUPPORTED;
 
-	self = BRASERO_MD5SUM_FILE (data);
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (self);
+	self = BRASERO_CHECKSUM_FILES (data);
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (self);
 
 	/* check DISC types and add checksums for DATA and IMAGE-bin types */
 	brasero_job_get_action (BRASERO_JOB (self), &action);
@@ -819,7 +819,7 @@
 		brasero_job_get_current_track (BRASERO_JOB (self), &track);
 		type = brasero_track_get_checksum_type (track);
 		if (type & (BRASERO_CHECKSUM_MD5_FILE|BRASERO_CHECKSUM_SHA1_FILE|BRASERO_CHECKSUM_SHA256))
-			result = brasero_md5sum_file_check_files (self, type, &error);
+			result = brasero_checksum_files_check_files (self, type, &error);
 		else
 			result = BRASERO_BURN_ERR;
 	}
@@ -828,20 +828,20 @@
 
 		brasero_job_get_input_type (BRASERO_JOB (self), &type);
 		if (type.type == BRASERO_TRACK_TYPE_DATA)
-			result = brasero_md5sum_file_create_checksum (self, &error);
+			result = brasero_checksum_files_create_checksum (self, &error);
 		else
 			result = BRASERO_BURN_ERR;
 	}
 
 	if (result != BRASERO_BURN_CANCEL) {
-		ctx = g_new0 (BraseroMd5sumFileThreadCtx, 1);
+		ctx = g_new0 (BraseroChecksumFilesThreadCtx, 1);
 		ctx->sum = self;
 		ctx->error = error;
 		ctx->result = result;
 		priv->end_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE,
-						brasero_md5sum_file_end,
+						brasero_checksum_files_end,
 						ctx,
-						brasero_md5sum_file_destroy);
+						brasero_checksum_files_destroy);
 	}
 
 	priv->thread = NULL;
@@ -850,10 +850,10 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_file_start (BraseroJob *job,
-			   GError **error)
+brasero_checksum_files_start (BraseroJob *job,
+			      GError **error)
 {
-	BraseroMd5sumFilePrivate *priv;
+	BraseroChecksumFilesPrivate *priv;
 	BraseroJobAction action;
 
 	brasero_job_get_action (job, &action);
@@ -861,9 +861,9 @@
 		return BRASERO_BURN_NOT_SUPPORTED;
 
 	/* we start a thread for the exploration of the graft points */
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (job);
-	priv->thread = g_thread_create (brasero_md5sum_file_thread,
-					BRASERO_MD5SUM_FILE (job),
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (job);
+	priv->thread = g_thread_create (brasero_checksum_files_thread,
+					BRASERO_CHECKSUM_FILES (job),
 					TRUE,
 					error);
 
@@ -874,8 +874,8 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_file_activate (BraseroJob *job,
-			      GError **error)
+brasero_checksum_files_activate (BraseroJob *job,
+				 GError **error)
 {
 	GSList *grafts;
 	BraseroTrackType output;
@@ -907,11 +907,11 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_file_clock_tick (BraseroJob *job)
+brasero_checksum_files_clock_tick (BraseroJob *job)
 {
-	BraseroMd5sumFilePrivate *priv;
+	BraseroChecksumFilesPrivate *priv;
 
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (job);
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (job);
 
 	/* we'll need that function later. For the moment, when generating a
 	 * file we can't know how many files there are. Just when checking it */
@@ -920,12 +920,12 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_file_stop (BraseroJob *job,
-		     GError **error)
+brasero_checksum_files_stop (BraseroJob *job,
+			     GError **error)
 {
-	BraseroMd5sumFilePrivate *priv;
+	BraseroChecksumFilesPrivate *priv;
 
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (job);
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (job);
 
 	if (priv->thread) {
 		priv->cancel = 1;
@@ -953,15 +953,15 @@
 }
 
 static void
-brasero_md5sum_file_init (BraseroMd5sumFile *obj)
+brasero_checksum_files_init (BraseroChecksumFiles *obj)
 { }
 
 static void
-brasero_md5sum_file_finalize (GObject *object)
+brasero_checksum_files_finalize (GObject *object)
 {
-	BraseroMd5sumFilePrivate *priv;
+	BraseroChecksumFilesPrivate *priv;
 	
-	priv = BRASERO_MD5SUM_FILE_PRIVATE (object);
+	priv = BRASERO_CHECKSUM_FILES_PRIVATE (object);
 
 	if (priv->thread) {
 		priv->cancel = 1;
@@ -984,30 +984,30 @@
 }
 
 static void
-brasero_md5sum_file_class_init (BraseroMd5sumFileClass *klass)
+brasero_checksum_files_class_init (BraseroChecksumFilesClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 	BraseroJobClass *job_class = BRASERO_JOB_CLASS (klass);
 
-	g_type_class_add_private (klass, sizeof (BraseroMd5sumFilePrivate));
+	g_type_class_add_private (klass, sizeof (BraseroChecksumFilesPrivate));
 
 	parent_class = g_type_class_peek_parent (klass);
-	object_class->finalize = brasero_md5sum_file_finalize;
+	object_class->finalize = brasero_checksum_files_finalize;
 
-	job_class->activate = brasero_md5sum_file_activate;
-	job_class->start = brasero_md5sum_file_start;
-	job_class->stop = brasero_md5sum_file_stop;
-	job_class->clock_tick = brasero_md5sum_file_clock_tick;
+	job_class->activate = brasero_checksum_files_activate;
+	job_class->start = brasero_checksum_files_start;
+	job_class->stop = brasero_checksum_files_stop;
+	job_class->clock_tick = brasero_checksum_files_clock_tick;
 }
 
 static BraseroBurnResult
-brasero_md5sum_file_export_caps (BraseroPlugin *plugin, gchar **error)
+brasero_checksum_files_export_caps (BraseroPlugin *plugin, gchar **error)
 {
 	GSList *input;
 	BraseroPluginConfOption *checksum_type;
 
 	brasero_plugin_define (plugin,
-			       "md5sum-file",
+			       "File checksum",
 			       _("allows to check file integrities on a disc"),
 			       "Philippe Rouquier",
 			       0);

Modified: trunk/src/plugins/checksum/burn-checksum-files.h
==============================================================================
--- trunk/src/plugins/checksum/burn-checksum-files.h	(original)
+++ trunk/src/plugins/checksum/burn-checksum-files.h	Fri Mar 14 08:40:59 2008
@@ -30,12 +30,12 @@
 
 G_BEGIN_DECLS
 
-#define BRASERO_TYPE_MD5SUM_FILE		(brasero_md5sum_file_get_type ())
-#define BRASERO_MD5SUM_FILE(o)			(G_TYPE_CHECK_INSTANCE_CAST ((o), BRASERO_TYPE_MD5SUM_FILE, BraseroMd5sumFile))
-#define BRASERO_MD5SUM_FILE_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), BRASERO_TYPE_MD5SUM_FILE, BraseroMd5sumFileClass))
-#define BRASERO_IS_MD5SUM_FILE(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), BRASERO_TYPE_MD5SUM_FILE))
-#define BRASERO_IS_MD5SUM_FILE_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), BRASERO_TYPE_MD5SUM_FILE))
-#define BRASERO_MD5SUM_FILE_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), BRASERO_TYPE_MD5SUM_FILE, BraseroMd5sumFileClass))
+#define BRASERO_TYPE_CHECKSUM_FILES		(brasero_checksum_files_get_type ())
+#define BRASERO_CHECKSUM_FILES(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), BRASERO_TYPE_CHECKSUM_FILES, BraseroChecksumFiles))
+#define BRASERO_CHECKSUM_FILES_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), BRASERO_TYPE_CHECKSUM_FILES, BraseroChecksumFilesClass))
+#define BRASERO_IS_CHECKSUM_FILES(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), BRASERO_TYPE_CHECKSUM_FILES))
+#define BRASERO_IS_CHECKSUM_FILES_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), BRASERO_TYPE_CHECKSUM_FILES))
+#define BRASERO_CHECKSUM_FILES_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), BRASERO_TYPE_CHECKSUM_FILES, BraseroChecksumFilesClass))
 
 G_END_DECLS
 

Modified: trunk/src/plugins/checksum/burn-checksum-image.c
==============================================================================
--- trunk/src/plugins/checksum/burn-checksum-image.c	(original)
+++ trunk/src/plugins/checksum/burn-checksum-image.c	Fri Mar 14 08:40:59 2008
@@ -49,9 +49,9 @@
 #include "burn-volume.h"
 #include "burn-drive.h"
 
-BRASERO_PLUGIN_BOILERPLATE (BraseroMd5sum, brasero_md5sum, BRASERO_TYPE_JOB, BraseroJob);
+BRASERO_PLUGIN_BOILERPLATE (BraseroChecksumImage, brasero_checksum_image, BRASERO_TYPE_JOB, BraseroJob);
 
-struct _BraseroMd5sumPrivate {
+struct _BraseroChecksumImagePrivate {
 	GChecksum *checksum;
 	BraseroChecksumType checksum_type;
 
@@ -65,16 +65,16 @@
 
 	guint cancel;
 };
-typedef struct _BraseroMd5sumPrivate BraseroMd5sumPrivate;
+typedef struct _BraseroChecksumImagePrivate BraseroChecksumImagePrivate;
 
-#define BRASERO_MD5SUM_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), BRASERO_TYPE_MD5SUM, BraseroMd5sumPrivate))
+#define BRASERO_CHECKSUM_IMAGE_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), BRASERO_TYPE_CHECKSUM_IMAGE, BraseroChecksumImagePrivate))
 
 #define GCONF_KEY_CHECKSUM_TYPE		"/apps/brasero/config/checksum_image"
 
 static BraseroJobClass *parent_class = NULL;
 
 static gint
-brasero_md5sum_read (BraseroMd5sum *self,
+brasero_checksum_image_read (BraseroChecksumImage *self,
 		     int fd,
 		     guchar *buffer,
 		     gint bytes,
@@ -82,9 +82,9 @@
 {
 	gint total = 0;
 	gint read_bytes;
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 
-	priv = BRASERO_MD5SUM_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (self);
 
 	while (1) {
 		read_bytes = read (fd, buffer + total, (bytes - total));
@@ -122,7 +122,7 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_write (BraseroMd5sum *self,
+brasero_checksum_image_write (BraseroChecksumImage *self,
 		      int fd,
 		      guchar *buffer,
 		      gint bytes,
@@ -130,9 +130,9 @@
 {
 	gint bytes_remaining;
 	gint bytes_written = 0;
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 
-	priv = BRASERO_MD5SUM_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (self);
 
 	bytes_remaining = bytes;
 	while (bytes_remaining) {
@@ -170,7 +170,7 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_checksum (BraseroMd5sum *self,
+brasero_checksum_image_checksum (BraseroChecksumImage *self,
 			 GChecksumType checksum_type,
 			 int fd_in,
 			 int fd_out,
@@ -179,14 +179,14 @@
 	gint read_bytes;
 	guchar buffer [2048];
 	BraseroBurnResult result;
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 
-	priv = BRASERO_MD5SUM_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (self);
 
 	priv->checksum = g_checksum_new (checksum_type);
 	result = BRASERO_BURN_OK;
 	while (1) {
-		read_bytes = brasero_md5sum_read (self,
+		read_bytes = brasero_checksum_image_read (self,
 						  fd_in,
 						  buffer,
 						  sizeof (buffer),
@@ -203,7 +203,7 @@
 		/* it can happen when we're just asked to generate a checksum
 		 * that we don't need to output the received data */
 		if (fd_out > 0) {
-			result = brasero_md5sum_write (self,
+			result = brasero_checksum_image_write (self,
 						       fd_out,
 						       buffer,
 						       read_bytes, error);
@@ -222,16 +222,16 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_checksum_fd_input (BraseroMd5sum *self,
+brasero_checksum_image_checksum_fd_input (BraseroChecksumImage *self,
 				  GChecksumType checksum_type,
 				  GError **error)
 {
 	int fd_in = -1;
 	int fd_out = -1;
 	BraseroBurnResult result;
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 
-	priv = BRASERO_MD5SUM_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (self);
 
 	BRASERO_JOB_LOG (self, "Starting md5 generation live (size = %i)", priv->total);
 	result = brasero_job_set_nonblocking (BRASERO_JOB (self), error);
@@ -241,22 +241,22 @@
 	brasero_job_get_fd_in (BRASERO_JOB (self), &fd_in);
 	brasero_job_get_fd_out (BRASERO_JOB (self), &fd_out);
 
-	return brasero_md5sum_checksum (self, checksum_type, fd_in, fd_out, error);
+	return brasero_checksum_image_checksum (self, checksum_type, fd_in, fd_out, error);
 }
 
 static BraseroBurnResult
-brasero_md5sum_checksum_file_input (BraseroMd5sum *self,
+brasero_checksum_image_checksum_file_input (BraseroChecksumImage *self,
 				    GChecksumType checksum_type,
 				    GError **error)
 {
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 	BraseroBurnResult result;
 	BraseroTrack *track;
 	int fd_out = -1;
 	int fd_in = -1;
 	gchar *path;
 
-	priv = BRASERO_MD5SUM_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (self);
 
 	BRASERO_JOB_LOG (self,
 			 "Starting checksuming file %s (size = %i)",
@@ -297,7 +297,7 @@
 
 	/* and here we go */
 	brasero_job_get_fd_out (BRASERO_JOB (self), &fd_out);
-	result = brasero_md5sum_checksum (self, checksum_type, fd_in, fd_out, error);
+	result = brasero_checksum_image_checksum (self, checksum_type, fd_in, fd_out, error);
 	g_free (path);
 	close (fd_in);
 
@@ -305,15 +305,15 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_create_checksum (BraseroMd5sum *self,
+brasero_checksum_image_create_checksum (BraseroChecksumImage *self,
 				GError **error)
 {
 	BraseroBurnResult result;
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 	BraseroTrack *track = NULL;
 	GChecksumType checksum_type;
 
-	priv = BRASERO_MD5SUM_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (self);
 
 	/* get the checksum type */
 	switch (priv->checksum_type) {
@@ -348,7 +348,7 @@
 							  &priv->total,
 							  NULL);
 
-		return brasero_md5sum_checksum_fd_input (self, checksum_type, error);
+		return brasero_checksum_image_checksum_fd_input (self, checksum_type, error);
 	}
 	else {
 		result = brasero_track_get_image_size (track,
@@ -359,22 +359,22 @@
 		if (result != BRASERO_BURN_OK)
 			return result;
 
-		return brasero_md5sum_checksum_file_input (self, checksum_type, error);
+		return brasero_checksum_image_checksum_file_input (self, checksum_type, error);
 	}
 
 	return BRASERO_BURN_OK;
 }
 
 static BraseroBurnResult
-brasero_md5sum_image_and_checksum (BraseroMd5sum *self,
+brasero_checksum_image_image_and_checksum (BraseroChecksumImage *self,
 				   GError **error)
 {
 	GConfClient *client;
 	BraseroBurnResult result;
 	GChecksumType checksum_type;
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 
-	priv = BRASERO_MD5SUM_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (self);
 	client = gconf_client_get_default ();
 	priv->checksum_type = gconf_client_get_int (client, GCONF_KEY_CHECKSUM_TYPE, NULL);
 	g_object_unref (client);
@@ -391,33 +391,33 @@
 		checksum_type = G_CHECKSUM_MD5;
 
 	if (brasero_job_get_fd_in (BRASERO_JOB (self), NULL) == BRASERO_BURN_OK)
-		result = brasero_md5sum_checksum_fd_input (self, checksum_type, error);
+		result = brasero_checksum_image_checksum_fd_input (self, checksum_type, error);
 	else
-		result = brasero_md5sum_checksum_file_input (self, checksum_type, error);
+		result = brasero_checksum_image_checksum_file_input (self, checksum_type, error);
 
 	return result;
 }
 
-struct _BraseroMd5sumThreadCtx {
-	BraseroMd5sum *sum;
+struct _BraseroChecksumImageThreadCtx {
+	BraseroChecksumImage *sum;
 	BraseroBurnResult result;
 	GError *error;
 };
-typedef struct _BraseroMd5sumThreadCtx BraseroMd5sumThreadCtx;
+typedef struct _BraseroChecksumImageThreadCtx BraseroChecksumImageThreadCtx;
 
 static gboolean
-brasero_md5sum_end (gpointer data)
+brasero_checksum_image_end (gpointer data)
 {
-	BraseroMd5sum *self;
+	BraseroChecksumImage *self;
 	BraseroTrack *track;
 	const gchar *checksum;
 	BraseroBurnResult result;
-	BraseroMd5sumPrivate *priv;
-	BraseroMd5sumThreadCtx *ctx;
+	BraseroChecksumImagePrivate *priv;
+	BraseroChecksumImageThreadCtx *ctx;
 
 	ctx = data;
 	self = ctx->sum;
-	priv = BRASERO_MD5SUM_PRIVATE (self);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (self);
 
 	/* NOTE ctx/data is destroyed in its own callback */
 	priv->end_id = 0;
@@ -473,9 +473,9 @@
 }
 
 static void
-brasero_md5sum_destroy (gpointer data)
+brasero_checksum_image_destroy (gpointer data)
 {
-	BraseroMd5sumThreadCtx *ctx;
+	BraseroChecksumImageThreadCtx *ctx;
 
 	ctx = data;
 	if (ctx->error) {
@@ -487,17 +487,17 @@
 }
 
 static gpointer
-brasero_md5sum_thread (gpointer data)
+brasero_checksum_image_thread (gpointer data)
 {
-	BraseroMd5sum *self;
+	BraseroChecksumImage *self;
 	GError *error = NULL;
 	BraseroJobAction action;
-	BraseroMd5sumPrivate *priv;
-	BraseroMd5sumThreadCtx *ctx;
+	BraseroChecksumImagePrivate *priv;
+	BraseroChecksumImageThreadCtx *ctx;
 	BraseroBurnResult result = BRASERO_BURN_NOT_SUPPORTED;
 
-	self = BRASERO_MD5SUM (data);
-	priv = BRASERO_MD5SUM_PRIVATE (self);
+	self = BRASERO_CHECKSUM_IMAGE (data);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (self);
 
 	/* check DISC types and add checksums for DATA and IMAGE-bin types */
 	brasero_job_get_action (BRASERO_JOB (self), &action);
@@ -508,7 +508,7 @@
 		brasero_job_get_current_track (BRASERO_JOB (self), &track);
 		priv->checksum_type = brasero_track_get_checksum_type (track);
 		if (priv->checksum_type & (BRASERO_CHECKSUM_MD5|BRASERO_CHECKSUM_SHA1|BRASERO_CHECKSUM_SHA256))
-			result = brasero_md5sum_create_checksum (self, &error);
+			result = brasero_checksum_image_create_checksum (self, &error);
 		else
 			result = BRASERO_BURN_ERR;
 	}
@@ -517,20 +517,20 @@
 
 		brasero_job_get_input_type (BRASERO_JOB (self), &type);
 		if (type.type == BRASERO_TRACK_TYPE_IMAGE)
-			result = brasero_md5sum_image_and_checksum (self, &error);
+			result = brasero_checksum_image_image_and_checksum (self, &error);
 		else
 			result = BRASERO_BURN_ERR;
 	}
 
 	if (result != BRASERO_BURN_CANCEL) {
-		ctx = g_new0 (BraseroMd5sumThreadCtx, 1);
+		ctx = g_new0 (BraseroChecksumImageThreadCtx, 1);
 		ctx->sum = self;
 		ctx->error = error;
 		ctx->result = result;
 		priv->end_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE,
-						brasero_md5sum_end,
+						brasero_checksum_image_end,
 						ctx,
-						brasero_md5sum_destroy);
+						brasero_checksum_image_destroy);
 	}
 
 	priv->thread = NULL;
@@ -539,10 +539,10 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_start (BraseroJob *job,
-		      GError **error)
+brasero_checksum_image_start (BraseroJob *job,
+			      GError **error)
 {
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 	BraseroJobAction action;
 
 	brasero_job_get_action (job, &action);
@@ -550,9 +550,9 @@
 		return BRASERO_BURN_NOT_SUPPORTED;
 
 	/* we start a thread for the exploration of the graft points */
-	priv = BRASERO_MD5SUM_PRIVATE (job);
-	priv->thread = g_thread_create (brasero_md5sum_thread,
-					BRASERO_MD5SUM (job),
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (job);
+	priv->thread = g_thread_create (brasero_checksum_image_thread,
+					BRASERO_CHECKSUM_IMAGE (job),
 					TRUE,
 					error);
 
@@ -563,11 +563,11 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_clock_tick (BraseroJob *job)
+brasero_checksum_image_clock_tick (BraseroJob *job)
 {
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 
-	priv = BRASERO_MD5SUM_PRIVATE (job);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (job);
 	if (!priv->checksum)
 		return BRASERO_BURN_OK;
 
@@ -582,12 +582,12 @@
 }
 
 static BraseroBurnResult
-brasero_md5sum_stop (BraseroJob *job,
-		     GError **error)
+brasero_checksum_image_stop (BraseroJob *job,
+			     GError **error)
 {
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 
-	priv = BRASERO_MD5SUM_PRIVATE (job);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (job);
 
 	if (priv->thread) {
 		priv->cancel = 1;
@@ -610,15 +610,15 @@
 }
 
 static void
-brasero_md5sum_init (BraseroMd5sum *obj)
+brasero_checksum_image_init (BraseroChecksumImage *obj)
 { }
 
 static void
-brasero_md5sum_finalize (GObject *object)
+brasero_checksum_image_finalize (GObject *object)
 {
-	BraseroMd5sumPrivate *priv;
+	BraseroChecksumImagePrivate *priv;
 	
-	priv = BRASERO_MD5SUM_PRIVATE (object);
+	priv = BRASERO_CHECKSUM_IMAGE_PRIVATE (object);
 
 	if (priv->thread) {
 		priv->cancel = 1;
@@ -641,29 +641,29 @@
 }
 
 static void
-brasero_md5sum_class_init (BraseroMd5sumClass *klass)
+brasero_checksum_image_class_init (BraseroChecksumImageClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 	BraseroJobClass *job_class = BRASERO_JOB_CLASS (klass);
 
-	g_type_class_add_private (klass, sizeof (BraseroMd5sumPrivate));
+	g_type_class_add_private (klass, sizeof (BraseroChecksumImagePrivate));
 
 	parent_class = g_type_class_peek_parent (klass);
-	object_class->finalize = brasero_md5sum_finalize;
+	object_class->finalize = brasero_checksum_image_finalize;
 
-	job_class->start = brasero_md5sum_start;
-	job_class->stop = brasero_md5sum_stop;
-	job_class->clock_tick = brasero_md5sum_clock_tick;
+	job_class->start = brasero_checksum_image_start;
+	job_class->stop = brasero_checksum_image_stop;
+	job_class->clock_tick = brasero_checksum_image_clock_tick;
 }
 
 static BraseroBurnResult
-brasero_md5sum_export_caps (BraseroPlugin *plugin, gchar **error)
+brasero_checksum_image_export_caps (BraseroPlugin *plugin, gchar **error)
 {
 	GSList *input;
 	BraseroPluginConfOption *checksum_type;
 
 	brasero_plugin_define (plugin,
-			       "md5sum",
+			       "Image checksum",
 			       _("allows to check data integrity on disc after it is burnt"),
 			       "Philippe Rouquier",
 			       0);

Modified: trunk/src/plugins/checksum/burn-checksum-image.h
==============================================================================
--- trunk/src/plugins/checksum/burn-checksum-image.h	(original)
+++ trunk/src/plugins/checksum/burn-checksum-image.h	Fri Mar 14 08:40:59 2008
@@ -30,14 +30,12 @@
 
 G_BEGIN_DECLS
 
-#define BRASERO_TYPE_MD5SUM		(brasero_md5sum_get_type ())
-#define BRASERO_MD5SUM(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), BRASERO_TYPE_MD5SUM, BraseroMd5sum))
-#define BRASERO_MD5SUM_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), BRASERO_TYPE_MD5SUM, BraseroMd5sumClass))
-#define BRASERO_IS_MD5SUM(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), BRASERO_TYPE_MD5SUM))
-#define BRASERO_IS_MD5SUM_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), BRASERO_TYPE_MD5SUM))
-#define BRASERO_MD5SUM_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), BRASERO_TYPE_MD5SUM, BraseroMd5sumClass))
-
-#define BRASERO_CHECKSUM_FILE	".checksum.md5"
+#define BRASERO_TYPE_CHECKSUM_IMAGE		(brasero_checksum_image_get_type ())
+#define BRASERO_CHECKSUM_IMAGE(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), BRASERO_TYPE_CHECKSUM_IMAGE, BraseroChecksumImage))
+#define BRASERO_CHECKSUM_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), BRASERO_TYPE_CHECKSUM_IMAGE, BraseroChecksumImageClass))
+#define BRASERO_IS_CHECKSUM_IMAGE(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), BRASERO_TYPE_CHECKSUM_IMAGE))
+#define BRASERO_IS_CHECKSUM_IMAGE_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), BRASERO_TYPE_CHECKSUM_IMAGE))
+#define BRASERO_CHECKSUM_GET_CLASS(o)		(G_TYPE_INSTANCE_GET_CLASS ((o), BRASERO_TYPE_CHECKSUM_IMAGE, BraseroChecksumImageClass))
 
 G_END_DECLS
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]