File gnome-multi-writer-Use-G_DECLARE_FINAL_TYPE.patch of Package gnome-multi-writer

Overview Repositories Revisions Requests Users Attributes Meta

File gnome-multi-writer-Use-G_DECLARE_FINAL_TYPE.patch of Package gnome-multi-writer (Revision 0e54bb9e2d36defe4eb66f44cc96e20f)

Currently displaying revision 0e54bb9e2d36defe4eb66f44cc96e20f , Show latest

From 153aeafbfb24eb426a4a0633f3780ba9938cd458 Mon Sep 17 00:00:00 2001
From: Richard Hughes <richard@hughsie.com>
Date: Thu, 1 Nov 2018 11:29:34 +0000
Subject: [PATCH] Use G_DECLARE_FINAL_TYPE for GmwDevice

---
 src/gmw-device.c | 455 +++++++++++++++++++++--------------------------
 src/gmw-device.h |  76 ++++----
 2 files changed, 243 insertions(+), 288 deletions(-)

diff --git a/src/gmw-device.c b/src/gmw-device.c
index f62cf21..0054608 100644
--- a/src/gmw-device.c
+++ b/src/gmw-device.c
@@ -27,7 +27,7 @@
 #include "gmw-cleanup.h"
 #include "gmw-device.h"
 
-typedef struct {
+struct _GmwDevice {
 	GError			*error;		/* the error, if any */
 	GMutex			 mutex;		/* mutex for the device */
 	GmwDeviceState		 state;		/* the #GmwDeviceState, e.g. %GMW_DEVICE_STATE_WRITE */
@@ -45,156 +45,140 @@ typedef struct {
 	gdouble			 speed_read;	/* throughput in bytes/sec */
 	gdouble			 speed_write;	/* throughput in bytes/sec */
 	gdouble			 write_alloc;	/* the proportion to allocate to writing */
-} GmwDevicePrivate;
+};
 
-G_DEFINE_TYPE_WITH_PRIVATE (GmwDevice, gmw_device, G_TYPE_OBJECT)
+G_DEFINE_TYPE (GmwDevice, gmw_device, G_TYPE_OBJECT)
 
 GmwDeviceState
-gmw_device_get_state (GmwDevice *device)
+gmw_device_get_state (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), GMW_DEVICE_STATE_UNKNOWN);
-	return priv->state;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), GMW_DEVICE_STATE_UNKNOWN);
+	return self->state;
 }
 
 UDisksBlock *
-gmw_device_get_udisks_block (GmwDevice *device)
+gmw_device_get_udisks_block (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
-	return priv->udisks_block;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
+	return self->udisks_block;
 }
 
 const gchar *
-gmw_device_get_name (GmwDevice *device)
+gmw_device_get_name (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
-	return priv->name;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
+	return self->name;
 }
 
 const gchar *
-gmw_device_get_block_path (GmwDevice *device)
+gmw_device_get_block_path (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
-	return priv->block_path;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
+	return self->block_path;
 }
 
 const gchar *
-gmw_device_get_hub_label (GmwDevice *device)
+gmw_device_get_hub_label (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
-	return priv->hub_label;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
+	return self->hub_label;
 }
 
 const gchar *
-gmw_device_get_hub_id (GmwDevice *device)
+gmw_device_get_hub_id (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
-	return priv->hub_id;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
+	return self->hub_id;
 }
 
 guint8
-gmw_device_get_hub_root (GmwDevice *device)
+gmw_device_get_hub_root (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), 0);
-	if (priv->usb_device == NULL)
+	g_return_val_if_fail (GMW_IS_DEVICE (self), 0);
+	if (self->usb_device == NULL)
 		return 0x00;
-	return g_usb_device_get_bus (priv->usb_device);
+	return g_usb_device_get_bus (self->usb_device);
 }
 
 const gchar *
-gmw_device_get_object_path (GmwDevice *device)
+gmw_device_get_object_path (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
-	return priv->object_path;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
+	return self->object_path;
 }
 
 const gchar *
-gmw_device_get_order_display (GmwDevice *device)
+gmw_device_get_order_display (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
-	if (priv->order_display == NULL) {
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
+	if (self->order_display == NULL) {
 		g_autofree gchar *key = NULL;
-		key = g_strdup_printf ("%s-%s", priv->hub_id, priv->hub_label);
-		gmw_device_set_order_display (device, key);
+		key = g_strdup_printf ("%s-%s", self->hub_id, self->hub_label);
+		gmw_device_set_order_display (self, key);
 	}
-	return priv->order_display;
+	return self->order_display;
 }
 
 const gchar *
-gmw_device_get_order_process (GmwDevice *device)
+gmw_device_get_order_process (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
-	if (priv->order_process == NULL)
-		return gmw_device_get_order_display (device);
-	return priv->order_process;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
+	if (self->order_process == NULL)
+		return gmw_device_get_order_display (self);
+	return self->order_process;
 }
 
 const gchar *
-gmw_device_get_sysfs_path (GmwDevice *device)
+gmw_device_get_sysfs_path (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
-	return priv->sysfs_path;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
+	return self->sysfs_path;
 }
 
 gdouble
-gmw_device_get_complete (GmwDevice *device)
+gmw_device_get_complete (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), -1.f);
-	return priv->complete;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), -1.f);
+	return self->complete;
 }
 
 gdouble
-gmw_device_get_speed_write (GmwDevice *device)
+gmw_device_get_speed_write (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), -1.f);
-	return priv->speed_write;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), -1.f);
+	return self->speed_write;
 }
 
 gdouble
-gmw_device_get_speed_read (GmwDevice *device)
+gmw_device_get_speed_read (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), -1.f);
-	return priv->speed_read;
+	g_return_val_if_fail (GMW_IS_DEVICE (self), -1.f);
+	return self->speed_read;
 }
 
 guint64
-gmw_device_get_size (GmwDevice *device)
+gmw_device_get_size (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_val_if_fail (GMW_IS_DEVICE (device), 0);
-	if (priv->udisks_block == NULL)
+	g_return_val_if_fail (GMW_IS_DEVICE (self), 0);
+	if (self->udisks_block == NULL)
 		return 0;
-	return udisks_block_get_size (priv->udisks_block);
+	return udisks_block_get_size (self->udisks_block);
 }
 
 const gchar *
-gmw_device_get_icon (GmwDevice *device)
+gmw_device_get_icon (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
 
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
 
-	if (priv->state == GMW_DEVICE_STATE_SUCCESS)
+	if (self->state == GMW_DEVICE_STATE_SUCCESS)
 		return "emblem-default";
-	if (priv->state == GMW_DEVICE_STATE_FAILED)
+	if (self->state == GMW_DEVICE_STATE_FAILED)
 		return "drive-harddisk";
 
 	/* try to get from UDisks */
-	if (priv->udisks_block != NULL) {
-		const gchar *tmp = udisks_block_get_hint_icon_name (priv->udisks_block);
+	if (self->udisks_block != NULL) {
+		const gchar *tmp = udisks_block_get_hint_icon_name (self->udisks_block);
 		if (tmp != NULL && tmp[0] != '\0')
 			return tmp;
 	}
@@ -203,51 +187,50 @@ gmw_device_get_icon (GmwDevice *device)
 }
 
 gchar *
-gmw_device_get_description (GmwDevice *device)
+gmw_device_get_description (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
 
-	g_return_val_if_fail (GMW_IS_DEVICE (device), NULL);
+	g_return_val_if_fail (GMW_IS_DEVICE (self), NULL);
 
 	/* waiting to be written */
-	if (priv->state == GMW_DEVICE_STATE_IDLE) {
-		guint64 size = gmw_device_get_size (device) / (1000 * 1000 * 1000);
+	if (self->state == GMW_DEVICE_STATE_IDLE) {
+		guint64 size = gmw_device_get_size (self) / (1000 * 1000 * 1000);
 		if (size == 0)
-			return g_strdup (priv->name);
+			return g_strdup (self->name);
 		return g_strdup_printf ("%s (%" G_GUINT64_FORMAT "GB)",
-					priv->name, size);
+					self->name, size);
 	}
 
 	/* failed to read or write */
-	if (priv->state == GMW_DEVICE_STATE_FAILED) {
-		if (priv->error == NULL) {
+	if (self->state == GMW_DEVICE_STATE_FAILED) {
+		if (self->error == NULL) {
 			/* TRANSLATORS: something internally has gone terribly
 			 * wrong if the user can see this */
 			return g_strdup ("Failed");
 		}
-		return g_strdup (priv->error->message);
+		return g_strdup (self->error->message);
 	}
 
 	/* waiting to be scheduled */
-	if (priv->state == GMW_DEVICE_STATE_WAITING) {
+	if (self->state == GMW_DEVICE_STATE_WAITING) {
 		/* TRANSLATORS: a device is waiting to be written in a queue */
 		return g_strdup ("Waiting");
 	}
 
 	/* bingo */
-	if (priv->state == GMW_DEVICE_STATE_SUCCESS) {
+	if (self->state == GMW_DEVICE_STATE_SUCCESS) {
 		/* TRANSLATORS: The image has been written and verified to
 		 * *one* device, not all */
 		return g_strdup (_("Written successfully"));
 	}
 
 	/* write */
-	if (priv->state == GMW_DEVICE_STATE_WRITE) {
-		if (priv->speed_write > 0.f) {
+	if (self->state == GMW_DEVICE_STATE_WRITE) {
+		if (self->speed_write > 0.f) {
 			/* TRANSLATORS: we're writing the image to the device
 			 * and we now know the speed */
 			return g_strdup_printf (_("Writing at %.1f MB/s…"),
-						priv->speed_write / (1000 * 1000));
+						self->speed_write / (1000 * 1000));
 		} else {
 			/* TRANSLATORS: we're writing the image to the USB device */
 			return g_strdup (_("Writing…"));
@@ -255,12 +238,12 @@ gmw_device_get_description (GmwDevice *device)
 	}
 
 	/* read */
-	if (priv->state == GMW_DEVICE_STATE_VERIFY) {
-		if (priv->speed_read > 0.f) {
+	if (self->state == GMW_DEVICE_STATE_VERIFY) {
+		if (self->speed_read > 0.f) {
 			/* TRANSLATORS: We're verifying the USB device contains
 			 * the correct image data and we now know the speed */
 			return g_strdup_printf (_("Verifying at %.1f MB/s…"),
-						priv->speed_read / (1000 * 1000));
+						self->speed_read / (1000 * 1000));
 		} else {
 			/* TRANSLATORS: We're verifying the USB device contains
 			 * the correct image data */
@@ -272,54 +255,50 @@ gmw_device_get_description (GmwDevice *device)
 }
 
 void
-gmw_device_set_state (GmwDevice *device, GmwDeviceState device_state)
+gmw_device_set_state (GmwDevice *self, GmwDeviceState device_state)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
+	g_return_if_fail (GMW_IS_DEVICE (self));
 	switch (device_state) {
 	case GMW_DEVICE_STATE_SUCCESS:
-		priv->complete = -1.f;
+		self->complete = -1.f;
 		break;
 	case GMW_DEVICE_STATE_IDLE:
 	case GMW_DEVICE_STATE_FAILED:
-		priv->speed_read = 0.f;
-		priv->speed_write = 0.f;
+		self->speed_read = 0.f;
+		self->speed_write = 0.f;
 		break;
 	default:
 		break;
 	}
-	priv->state = device_state;
+	self->state = device_state;
 }
 
 void
-gmw_device_set_error (GmwDevice *device, const GError *error)
+gmw_device_set_error (GmwDevice *self, const GError *error)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	g_mutex_lock (&priv->mutex);
-	if (priv->error != NULL)
-		g_error_free (priv->error);
-	priv->error = g_error_copy (error);
-	g_mutex_unlock (&priv->mutex);
-	gmw_device_set_state (device, GMW_DEVICE_STATE_FAILED);
-	gmw_device_set_complete_read (device, 0.f);
-	gmw_device_set_complete_write (device, 0.f);
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	g_mutex_lock (&self->mutex);
+	if (self->error != NULL)
+		g_error_free (self->error);
+	self->error = g_error_copy (error);
+	g_mutex_unlock (&self->mutex);
+	gmw_device_set_state (self, GMW_DEVICE_STATE_FAILED);
+	gmw_device_set_complete_read (self, 0.f);
+	gmw_device_set_complete_write (self, 0.f);
 }
 
 void
-gmw_device_set_udisks_block (GmwDevice *device, UDisksBlock *udisks_block)
+gmw_device_set_udisks_block (GmwDevice *self, UDisksBlock *udisks_block)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	g_mutex_lock (&priv->mutex);
-	g_set_object (&priv->udisks_block, udisks_block);
-	g_mutex_unlock (&priv->mutex);
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	g_mutex_lock (&self->mutex);
+	g_set_object (&self->udisks_block, udisks_block);
+	g_mutex_unlock (&self->mutex);
 }
 
 void
-gmw_device_set_name (GmwDevice *device, const gchar *name)
+gmw_device_set_name (GmwDevice *self, const gchar *name)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
 	struct {
 		const gchar *old;
 		const gchar *new;
@@ -329,7 +308,7 @@ gmw_device_set_name (GmwDevice *device, const gchar *name)
 		{ NULL, NULL }
 	};
 
-	g_return_if_fail (GMW_IS_DEVICE (device));
+	g_return_if_fail (GMW_IS_DEVICE (self));
 
 	/* replace any generic names */
 	for (guint i = 0; replace[i].old != NULL; i++) {
@@ -339,130 +318,118 @@ gmw_device_set_name (GmwDevice *device, const gchar *name)
 		}
 	}
 
-	g_mutex_lock (&priv->mutex);
-	g_free (priv->name);
-	priv->name = g_strdup (name);
-	g_mutex_unlock (&priv->mutex);
+	g_mutex_lock (&self->mutex);
+	g_free (self->name);
+	self->name = g_strdup (name);
+	g_mutex_unlock (&self->mutex);
 }
 
 void
-gmw_device_set_block_path (GmwDevice *device, const gchar *block_path)
+gmw_device_set_block_path (GmwDevice *self, const gchar *block_path)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	g_mutex_lock (&priv->mutex);
-	g_free (priv->block_path);
-	priv->block_path = g_strdup (block_path);
-	g_mutex_unlock (&priv->mutex);
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	g_mutex_lock (&self->mutex);
+	g_free (self->block_path);
+	self->block_path = g_strdup (block_path);
+	g_mutex_unlock (&self->mutex);
 }
 
 void
-gmw_device_set_hub_label (GmwDevice *device, const gchar *hub_label)
+gmw_device_set_hub_label (GmwDevice *self, const gchar *hub_label)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	g_mutex_lock (&priv->mutex);
-	g_free (priv->hub_label);
-	priv->hub_label = g_strdup (hub_label);
-	g_mutex_unlock (&priv->mutex);
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	g_mutex_lock (&self->mutex);
+	g_free (self->hub_label);
+	self->hub_label = g_strdup (hub_label);
+	g_mutex_unlock (&self->mutex);
 
 	/* invalidate */
-	gmw_device_set_order_display (device, NULL);
+	gmw_device_set_order_display (self, NULL);
 }
 
 void
-gmw_device_set_hub_id (GmwDevice *device, const gchar *hub_id)
+gmw_device_set_hub_id (GmwDevice *self, const gchar *hub_id)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	g_mutex_lock (&priv->mutex);
-	g_free (priv->hub_id);
-	priv->hub_id = g_strdup (hub_id);
-	g_mutex_unlock (&priv->mutex);
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	g_mutex_lock (&self->mutex);
+	g_free (self->hub_id);
+	self->hub_id = g_strdup (hub_id);
+	g_mutex_unlock (&self->mutex);
 }
 
 void
-gmw_device_set_object_path (GmwDevice *device, const gchar *object_path)
+gmw_device_set_object_path (GmwDevice *self, const gchar *object_path)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	g_mutex_lock (&priv->mutex);
-	g_free (priv->object_path);
-	priv->object_path = g_strdup (object_path);
-	g_mutex_unlock (&priv->mutex);
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	g_mutex_lock (&self->mutex);
+	g_free (self->object_path);
+	self->object_path = g_strdup (object_path);
+	g_mutex_unlock (&self->mutex);
 }
 
 void
-gmw_device_set_order_display (GmwDevice *device, const gchar *order_display)
+gmw_device_set_order_display (GmwDevice *self, const gchar *order_display)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	g_mutex_lock (&priv->mutex);
-	g_free (priv->order_display);
-	priv->order_display = g_strdup (order_display);
-	g_mutex_unlock (&priv->mutex);
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	g_mutex_lock (&self->mutex);
+	g_free (self->order_display);
+	self->order_display = g_strdup (order_display);
+	g_mutex_unlock (&self->mutex);
 }
 
 void
-gmw_device_set_order_process (GmwDevice *device, const gchar *order_process)
+gmw_device_set_order_process (GmwDevice *self, const gchar *order_process)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	g_mutex_lock (&priv->mutex);
-	g_free (priv->order_process);
-	priv->order_process = g_strdup (order_process);
-	g_mutex_unlock (&priv->mutex);
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	g_mutex_lock (&self->mutex);
+	g_free (self->order_process);
+	self->order_process = g_strdup (order_process);
+	g_mutex_unlock (&self->mutex);
 }
 
 void
-gmw_device_set_complete_read (GmwDevice *device, gdouble complete)
+gmw_device_set_complete_read (GmwDevice *self, gdouble complete)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	priv->complete = priv->write_alloc + (1.0 - priv->write_alloc) * complete;
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	self->complete = self->write_alloc + (1.0 - self->write_alloc) * complete;
 }
 
 void
-gmw_device_set_complete_write (GmwDevice *device, gdouble complete)
+gmw_device_set_complete_write (GmwDevice *self, gdouble complete)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	priv->complete = priv->write_alloc * complete;
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	self->complete = self->write_alloc * complete;
 }
 
 void
-gmw_device_set_speed_write (GmwDevice *device, gdouble speed_write)
+gmw_device_set_speed_write (GmwDevice *self, gdouble speed_write)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	priv->speed_write = speed_write;
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	self->speed_write = speed_write;
 }
 
 void
-gmw_device_set_speed_read (GmwDevice *device, gdouble speed_read)
+gmw_device_set_speed_read (GmwDevice *self, gdouble speed_read)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	priv->speed_read = speed_read;
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	self->speed_read = speed_read;
 }
 
 void
-gmw_device_set_write_alloc (GmwDevice *device, gdouble write_alloc)
+gmw_device_set_write_alloc (GmwDevice *self, gdouble write_alloc)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	g_return_if_fail (GMW_IS_DEVICE (device));
-	priv->write_alloc = write_alloc;
+	g_return_if_fail (GMW_IS_DEVICE (self));
+	self->write_alloc = write_alloc;
 }
 
 void
-gmw_device_set_udisks_drive (GmwDevice *device, UDisksDrive *udisks_drive)
+gmw_device_set_udisks_drive (GmwDevice *self, UDisksDrive *udisks_drive)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
 	const gchar *tmp;
 	g_autofree gchar *sysfs_path = NULL;
 	g_autofree gchar *hub_id = NULL;
 
-	g_return_if_fail (GMW_IS_DEVICE (device));
+	g_return_if_fail (GMW_IS_DEVICE (self));
 
 	/* get the sibling ID, which is normally the USB path */
 	tmp = udisks_drive_get_sibling_id (udisks_drive);
@@ -472,14 +439,14 @@ gmw_device_set_udisks_drive (GmwDevice *device, UDisksDrive *udisks_drive)
 	/* sometimes udisks goes insane */
 	sysfs_path = g_path_get_dirname (tmp);
 	if (g_file_test (sysfs_path, G_FILE_TEST_EXISTS)) {
-		priv->sysfs_path = g_strdup (sysfs_path);
+		self->sysfs_path = g_strdup (sysfs_path);
 	} else {
 		g_warning ("UDisks returned invalid path: %s", sysfs_path);
 	}
 
 	/* set the connection ID based on the parent device name */
 	hub_id = g_path_get_basename (sysfs_path);
-	gmw_device_set_hub_id (device, hub_id);
+	gmw_device_set_hub_id (self, hub_id);
 }
 
 typedef struct {
@@ -504,17 +471,16 @@ static GPtrArray *g_usb_device_get_children (GUsbDevice *d) {return g_ptr_array_
 #endif
 
 static GUsbDevice *
-gmw_device_get_toplevel_hub (GmwDevice *device)
+gmw_device_get_toplevel_hub (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
 	g_autoptr(GUsbDevice) usb_hub = NULL;
 	g_autoptr(GUsbDevice) usb_hub_parent = NULL;
 
 	/* is this a USB hub already */
-	if (g_usb_device_get_device_class (priv->usb_device) == 0x09) {
-		usb_hub = g_object_ref (priv->usb_device);
+	if (g_usb_device_get_device_class (self->usb_device) == 0x09) {
+		usb_hub = g_object_ref (self->usb_device);
 	} else {
-		usb_hub = g_usb_device_get_parent (priv->usb_device);
+		usb_hub = g_usb_device_get_parent (self->usb_device);
 		if (usb_hub == NULL)
 			return NULL;
 	}
@@ -531,9 +497,8 @@ gmw_device_get_toplevel_hub (GmwDevice *device)
 }
 
 gchar *
-gmw_device_get_quirk_string (GmwDevice *device)
+gmw_device_get_quirk_string (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
 	guint number_ics = 0;
 	g_autoptr(GUsbDevice) usb_hub_child = NULL;
 	g_autoptr(GUsbDevice) usb_hub = NULL;
@@ -544,14 +509,14 @@ gmw_device_get_quirk_string (GmwDevice *device)
 	g_autoptr(GString) str = NULL;
 
 	/* no tree to walk */
-	if (priv->usb_device == NULL)
+	if (self->usb_device == NULL)
 		return NULL;
 
 	/* is this a USB hub already */
-	if (g_usb_device_get_device_class (priv->usb_device) == 0x09) {
-		usb_hub = g_object_ref (priv->usb_device);
+	if (g_usb_device_get_device_class (self->usb_device) == 0x09) {
+		usb_hub = g_object_ref (self->usb_device);
 	} else {
-		usb_hub = g_usb_device_get_parent (priv->usb_device);
+		usb_hub = g_usb_device_get_parent (self->usb_device);
 		if (usb_hub == NULL)
 			return NULL;
 	}
@@ -563,7 +528,7 @@ gmw_device_get_quirk_string (GmwDevice *device)
 				g_usb_device_get_pid (usb_hub));
 
 	/* parent */
-	usb_hub_top = gmw_device_get_toplevel_hub (device);
+	usb_hub_top = gmw_device_get_toplevel_hub (self);
 	if (usb_hub_top == NULL) {
 		g_string_append_printf (str, "0x%02x, ", 0x00u);
 		g_string_append_printf (str, "0x%04x, 0x%04x, ", 0x0000u, 0x0000u);
@@ -607,24 +572,23 @@ gmw_device_get_quirk_string (GmwDevice *device)
 
 	/* device port */
 	g_string_append_printf (str, "0x%02x, ",
-				g_usb_device_get_port_number (priv->usb_device));
+				g_usb_device_get_port_number (self->usb_device));
 
 	/* chain length */
 	g_string_append_printf (str, "0x%01x, ", usb_hub_child ? 0x00u : 0x01u);
 
 	/* label */
-	if (priv->hub_label == NULL)
+	if (self->hub_label == NULL)
 		g_string_append_printf (str, "NULL },");
 	else
-		g_string_append_printf (str, "\"%s\" },", priv->hub_label);
+		g_string_append_printf (str, "\"%s\" },", self->hub_label);
 
 	return g_strdup (str->str);
 }
 
 void
-gmw_device_set_usb_device (GmwDevice *device, GUsbDevice *usb_device)
+gmw_device_set_usb_device (GmwDevice *self, GUsbDevice *usb_device)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
 	g_autofree gchar *hub_id = NULL;
 	g_autoptr(GUsbDevice) usb_hub = NULL;
 	g_autoptr(GUsbDevice) usb_hub_parent = NULL;
@@ -790,10 +754,10 @@ gmw_device_set_usb_device (GmwDevice *device, GUsbDevice *usb_device)
 	{ 0x0000, 0x0000, 0x00, 0x0000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, NULL }
 	};
 
-	g_return_if_fail (GMW_IS_DEVICE (device));
+	g_return_if_fail (GMW_IS_DEVICE (self));
 
 	/* get the USB root hub number */
-	priv->usb_device = g_object_ref (usb_device);
+	self->usb_device = g_object_ref (usb_device);
 
 	/* is this a USB hub already */
 	if (g_usb_device_get_device_class (usb_device) == 0x09) {
@@ -805,7 +769,7 @@ gmw_device_set_usb_device (GmwDevice *device, GUsbDevice *usb_device)
 	}
 
 	/* match */
-	usb_hub_toplevel = gmw_device_get_toplevel_hub (device);
+	usb_hub_toplevel = gmw_device_get_toplevel_hub (self);
 	usb_hub_parent = g_usb_device_get_parent (usb_hub);
 	g_debug ("Quirk info: 0x%04x:0x%04x@0x%02x -> "
 		 "0x%04x:0x%04x@0x%02x -> "
@@ -886,7 +850,7 @@ gmw_device_set_usb_device (GmwDevice *device, GUsbDevice *usb_device)
 		}
 
 		/* set the decal name */
-		gmw_device_set_hub_label (device, quirks[i].hub_label);
+		gmw_device_set_hub_label (self, quirks[i].hub_label);
 
 		/* get the top-level port address */
 		if (usb_hub_parent != NULL && quirks[i].chain_len == 1) {
@@ -898,7 +862,7 @@ gmw_device_set_usb_device (GmwDevice *device, GUsbDevice *usb_device)
 						g_usb_device_get_bus (usb_hub),
 						g_usb_device_get_address (usb_hub));
 		}
-		gmw_device_set_hub_id (device, hub_id);
+		gmw_device_set_hub_id (self, hub_id);
 		return;
 	}
 
@@ -906,34 +870,32 @@ gmw_device_set_usb_device (GmwDevice *device, GUsbDevice *usb_device)
 	hub_id = g_strdup_printf ("%02x:%02x",
 				  g_usb_device_get_bus (usb_hub),
 				  g_usb_device_get_address (usb_hub));
-	gmw_device_set_hub_id (device, hub_id);
+	gmw_device_set_hub_id (self, hub_id);
 }
 
 static void
 gmw_device_finalize (GObject *object)
 {
-	GmwDevice *device;
-	GmwDevicePrivate *priv;
+	GmwDevice *self;
 
 	g_return_if_fail (GMW_IS_DEVICE (object));
 
-	device = GMW_DEVICE (object);
-	priv = gmw_device_get_instance_private (device);
-
-	g_mutex_clear (&priv->mutex);
-	if (priv->error != NULL)
-		g_error_free (priv->error);
-	if (priv->usb_device != NULL)
-		g_object_unref (priv->usb_device);
-	g_free (priv->block_path);
-	g_free (priv->hub_id);
-	g_free (priv->hub_label);
-	g_free (priv->name);
-	g_free (priv->object_path);
-	g_free (priv->order_display);
-	g_free (priv->order_process);
-	g_free (priv->sysfs_path);
-	g_object_unref (priv->udisks_block);
+	self = GMW_DEVICE (object);
+
+	g_mutex_clear (&self->mutex);
+	if (self->error != NULL)
+		g_error_free (self->error);
+	if (self->usb_device != NULL)
+		g_object_unref (self->usb_device);
+	g_free (self->block_path);
+	g_free (self->hub_id);
+	g_free (self->hub_label);
+	g_free (self->name);
+	g_free (self->object_path);
+	g_free (self->order_display);
+	g_free (self->order_process);
+	g_free (self->sysfs_path);
+	g_object_unref (self->udisks_block);
 
 	G_OBJECT_CLASS (gmw_device_parent_class)->finalize (object);
 }
@@ -946,22 +908,19 @@ gmw_device_class_init (GmwDeviceClass *klass)
 }
 
 static void
-gmw_device_init (GmwDevice *device)
+gmw_device_init (GmwDevice *self)
 {
-	GmwDevicePrivate *priv = gmw_device_get_instance_private (device);
-	priv->state = GMW_DEVICE_STATE_IDLE;
-	priv->complete = -1.f;
-	priv->speed_read = -1.f;
-	priv->speed_write = -1.f;
-	priv->write_alloc = 1.f;
-	priv->hub_id = g_strdup ("???");
-	g_mutex_init (&priv->mutex);
+	self->state = GMW_DEVICE_STATE_IDLE;
+	self->complete = -1.f;
+	self->speed_read = -1.f;
+	self->speed_write = -1.f;
+	self->write_alloc = 1.f;
+	self->hub_id = g_strdup ("???");
+	g_mutex_init (&self->mutex);
 }
 
 GmwDevice *
 gmw_device_new (void)
 {
-	GmwDevice *device;
-	device = g_object_new (GMW_TYPE_DEVICE, NULL);
-	return GMW_DEVICE (device);
+	return g_object_new (GMW_TYPE_DEVICE, NULL);
 }
diff --git a/src/gmw-device.h b/src/gmw-device.h
index 0ea832b..a40d693 100644
--- a/src/gmw-device.h
+++ b/src/gmw-device.h
@@ -28,11 +28,7 @@
 #include <udisks/udisks.h>
 
 #define GMW_TYPE_DEVICE (gmw_device_get_type ())
-G_DECLARE_DERIVABLE_TYPE (GmwDevice, gmw_device, GMW, DEVICE, GObject)
-
-struct _GmwDeviceClass {
-	GObjectClass	 parent_class;
-};
+G_DECLARE_FINAL_TYPE (GmwDevice, gmw_device, GMW, DEVICE, GObject)
 
 typedef enum {
 	GMW_DEVICE_STATE_UNKNOWN,
@@ -46,58 +42,58 @@ typedef enum {
 } GmwDeviceState;
 
 GmwDevice	*gmw_device_new			(void);
-const gchar	*gmw_device_get_icon		(GmwDevice	*device);
-gchar		*gmw_device_get_description	(GmwDevice	*device);
-gchar		*gmw_device_get_quirk_string	(GmwDevice	*device);
-GmwDeviceState	 gmw_device_get_state		(GmwDevice	*device);
-UDisksBlock	*gmw_device_get_udisks_block	(GmwDevice	*device);
-const gchar	*gmw_device_get_name		(GmwDevice	*device);
-const gchar	*gmw_device_get_block_path	(GmwDevice	*device);
-const gchar	*gmw_device_get_hub_label	(GmwDevice	*device);
-const gchar	*gmw_device_get_hub_id		(GmwDevice	*device);
-guint8		 gmw_device_get_hub_root	(GmwDevice	*device);
-const gchar	*gmw_device_get_object_path	(GmwDevice	*device);
-const gchar	*gmw_device_get_order_display	(GmwDevice	*device);
-const gchar	*gmw_device_get_order_process	(GmwDevice	*device);
-const gchar	*gmw_device_get_sysfs_path	(GmwDevice	*device);
-gdouble		 gmw_device_get_complete	(GmwDevice	*device);
-gdouble		 gmw_device_get_speed_write	(GmwDevice	*device);
-gdouble		 gmw_device_get_speed_read	(GmwDevice	*device);
-guint64		 gmw_device_get_size		(GmwDevice	*device);
+const gchar	*gmw_device_get_icon		(GmwDevice	*self);
+gchar		*gmw_device_get_description	(GmwDevice	*self);
+gchar		*gmw_device_get_quirk_string	(GmwDevice	*self);
+GmwDeviceState	 gmw_device_get_state		(GmwDevice	*self);
+UDisksBlock	*gmw_device_get_udisks_block	(GmwDevice	*self);
+const gchar	*gmw_device_get_name		(GmwDevice	*self);
+const gchar	*gmw_device_get_block_path	(GmwDevice	*self);
+const gchar	*gmw_device_get_hub_label	(GmwDevice	*self);
+const gchar	*gmw_device_get_hub_id		(GmwDevice	*self);
+guint8		 gmw_device_get_hub_root	(GmwDevice	*self);
+const gchar	*gmw_device_get_object_path	(GmwDevice	*self);
+const gchar	*gmw_device_get_order_display	(GmwDevice	*self);
+const gchar	*gmw_device_get_order_process	(GmwDevice	*self);
+const gchar	*gmw_device_get_sysfs_path	(GmwDevice	*self);
+gdouble		 gmw_device_get_complete	(GmwDevice	*self);
+gdouble		 gmw_device_get_speed_write	(GmwDevice	*self);
+gdouble		 gmw_device_get_speed_read	(GmwDevice	*self);
+guint64		 gmw_device_get_size		(GmwDevice	*self);
 
-void		 gmw_device_set_state		(GmwDevice	*device,
+void		 gmw_device_set_state		(GmwDevice	*self,
 						 GmwDeviceState	 device_state);
-void		 gmw_device_set_udisks_block	(GmwDevice	*device,
+void		 gmw_device_set_udisks_block	(GmwDevice	*self,
 						 UDisksBlock	*udisks_block);
-void		 gmw_device_set_udisks_drive	(GmwDevice	*device,
+void		 gmw_device_set_udisks_drive	(GmwDevice	*self,
 						 UDisksDrive	*udisks_drive);
-void		 gmw_device_set_usb_device	(GmwDevice	*device,
+void		 gmw_device_set_usb_device	(GmwDevice	*self,
 						 GUsbDevice	*usb_device);
-void		 gmw_device_set_name		(GmwDevice	*device,
+void		 gmw_device_set_name		(GmwDevice	*self,
 						 const gchar	*name);
-void		 gmw_device_set_block_path	(GmwDevice	*device,
+void		 gmw_device_set_block_path	(GmwDevice	*self,
 						 const gchar	*block_path);
-void		 gmw_device_set_hub_id		(GmwDevice	*device,
+void		 gmw_device_set_hub_id		(GmwDevice	*self,
 						 const gchar	*hub_id);
-void		 gmw_device_set_hub_label	(GmwDevice	*device,
+void		 gmw_device_set_hub_label	(GmwDevice	*self,
 						 const gchar	*hub_label);
-void		 gmw_device_set_object_path	(GmwDevice	*device,
+void		 gmw_device_set_object_path	(GmwDevice	*self,
 						 const gchar	*object_path);
-void		 gmw_device_set_order_display	(GmwDevice	*device,
+void		 gmw_device_set_order_display	(GmwDevice	*self,
 						 const gchar	*order_display);
-void		 gmw_device_set_order_process	(GmwDevice	*device,
+void		 gmw_device_set_order_process	(GmwDevice	*self,
 						 const gchar	*order_process);
-void		 gmw_device_set_complete_read	(GmwDevice	*device,
+void		 gmw_device_set_complete_read	(GmwDevice	*self,
 						 gdouble	 complete);
-void		 gmw_device_set_complete_write	(GmwDevice	*device,
+void		 gmw_device_set_complete_write	(GmwDevice	*self,
 						 gdouble	 complete);
-void		 gmw_device_set_speed_write	(GmwDevice	*device,
+void		 gmw_device_set_speed_write	(GmwDevice	*self,
 						 gdouble	 speed_write);
-void		 gmw_device_set_speed_read	(GmwDevice	*device,
+void		 gmw_device_set_speed_read	(GmwDevice	*self,
 						 gdouble	 speed_read);
-void		 gmw_device_set_write_alloc	(GmwDevice	*device,
+void		 gmw_device_set_write_alloc	(GmwDevice	*self,
 						 gdouble	 write_alloc);
-void		 gmw_device_set_error		(GmwDevice	*device,
+void		 gmw_device_set_error		(GmwDevice	*self,
 						 const GError	*error);
 
 G_END_DECLS
-- 
2.18.1

Places

File gnome-multi-writer-Use-G_DECLARE_FINAL_TYPE.patch of Package gnome-multi-writer (Revision 0e54bb9e2d36defe4eb66f44cc96e20f)

Places