drivemount: Use common subdirs - data, src

6 files changed, 1921 insertions, 0 deletions

diff --git a/drivemount/src/Makefile.am b/drivemount/src/Makefile.am
new file mode 100644
index 00000000..28b273c0
--- /dev/null
+++ b/drivemount/src/Makefile.am
@@ -0,0 +1,43 @@
+NULL =
+
+AM_CPPFLAGS =				\
+	-I.				\
+	-I$(srcdir)			\
+	-DDRIVEMOUNT_RESOURCE_PATH=\""/org/mate/mate-applets/drivemount/"\" \
+	${WARN_CFLAGS}			\
+	$(MATE_APPLETS4_CFLAGS)		\
+	$(NULL)
+
+libexec_PROGRAMS = mate-drivemount-applet
+
+BUILT_SOURCES =				\
+	drivemount-resources.c		\
+	drivemount-resources.h		\
+	$(NULL)
+
+nodist_mate_drivemount_applet_SOURCES =	\
+	$(BUILT_SOURCES)		\
+	$(NULL)
+
+mate_drivemount_applet_SOURCES =	\
+	drivemount.c			\
+	drive-list.c			\
+	drive-list.h			\
+	drive-button.c			\
+	drive-button.h			\
+	$(NULL)
+
+mate_drivemount_applet_LDADD =		\
+	$(MATE_APPLETS4_LIBS)
+
+drivemount-resources.c: ../data/drivemount-resources.gresource.xml $(shell $(GLIB_COMPILE_RESOURCES) --sourcedir=$(srcdir)/../data/ --generate-dependencies $(srcdir)/../data/drivemount-resources.gresource.xml)
+	$(AM_V_GEN)$(GLIB_COMPILE_RESOURCES) --target=$@ --sourcedir=$(srcdir)/../data/ --generate --c-name drivemount $<
+
+drivemount-resources.h: ../data/drivemount-resources.gresource.xml $(shell $(GLIB_COMPILE_RESOURCES) --sourcedir=$(srcdir)/../data/ --generate-dependencies $(srcdir)/../data/drivemount-resources.gresource.xml)
+	$(AM_V_GEN)$(GLIB_COMPILE_RESOURCES) --target=$@ --sourcedir=$(srcdir)/../data/ --generate --c-name drivemount $<
+
+CLEANFILES =				\
+	$(BUILT_SOURCES)		\
+	$(NULL)
+
+-include $(top_srcdir)/git.mk
diff --git a/drivemount/src/drive-button.c b/drivemount/src/drive-button.c
new file mode 100644
index 00000000..f64f38c4
--- /dev/null
+++ b/drivemount/src/drive-button.c
@@ -0,0 +1,982 @@
+/* -*- mode: C; c-basic-offset: 4 -*-
+ * Drive Mount Applet
+ * Copyright (c) 2004 Canonical Ltd
+ * Copyright 2008 Pierre Ossman
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author:
+ *   James Henstridge <[email protected]>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gio/gio.h>
+#include "drive-button.h"
+#include <glib/gi18n.h>
+#include <gdk/gdkkeysyms.h>
+#include <gio/gdesktopappinfo.h>
+
+#include <string.h>
+
+enum {
+    CMD_NONE,
+    CMD_MOUNT_OR_PLAY,
+    CMD_UNMOUNT,
+    CMD_EJECT
+};
+
+/* type registration boilerplate code */
+G_DEFINE_TYPE (DriveButton, drive_button, GTK_TYPE_BUTTON)
+
+static void     drive_button_set_volume   (DriveButton    *self,
+                                           GVolume        *volume);
+static void     drive_button_set_mount    (DriveButton    *self,
+                                           GMount         *mount);
+static void     drive_button_reset_popup  (DriveButton    *self);
+static void     drive_button_ensure_popup (DriveButton    *self);
+
+static void     drive_button_dispose      (GObject        *object);
+#if 0
+static void     drive_button_unrealize    (GtkWidget      *widget);
+#endif /* 0 */
+static gboolean drive_button_button_press (GtkWidget      *widget,
+                                           GdkEventButton *event);
+static gboolean drive_button_key_press    (GtkWidget      *widget,
+                                           GdkEventKey    *event);
+static void drive_button_theme_change     (GtkIconTheme   *icon_theme,
+                                           gpointer        data);
+
+static void
+drive_button_class_init (DriveButtonClass *class)
+{
+    G_OBJECT_CLASS (class)->dispose = drive_button_dispose;
+    GTK_WIDGET_CLASS (class)->button_press_event = drive_button_button_press;
+    GTK_WIDGET_CLASS (class)->key_press_event = drive_button_key_press;
+
+    GtkCssProvider *provider;
+
+    provider = gtk_css_provider_new ();
+
+    gtk_css_provider_load_from_data (provider,
+                                     "#drive-button {\n"
+                                     " border-width: 0px;\n"
+                                     " padding: 0px;\n"
+                                     " margin: 0px;\n"
+                                     "}",
+                                     -1, NULL);
+
+    gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
+                                    GTK_STYLE_PROVIDER (provider),
+                                    GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+    g_object_unref (provider);
+}
+
+static void
+drive_button_init (DriveButton *self)
+{
+    GtkWidget *image;
+
+    image = gtk_image_new ();
+    gtk_container_add (GTK_CONTAINER (self), image);
+    gtk_widget_show (image);
+
+    self->volume = NULL;
+    self->mount = NULL;
+    self->icon_size = 24;
+    self->update_tag = 0;
+
+    self->popup_menu = NULL;
+
+    gtk_widget_set_name (GTK_WIDGET (self), "drive-button");
+}
+
+GtkWidget *
+drive_button_new (GVolume *volume)
+{
+    DriveButton *self;
+
+    self = g_object_new (DRIVE_TYPE_BUTTON, NULL);
+    if (volume != NULL) {
+      drive_button_set_volume (self, volume);
+      g_signal_connect (gtk_icon_theme_get_default (),
+          "changed", G_CALLBACK (drive_button_theme_change),
+          self);
+    }
+
+    return (GtkWidget *)self;
+}
+
+GtkWidget *
+drive_button_new_from_mount (GMount *mount)
+{
+    DriveButton *self;
+
+    self = g_object_new (DRIVE_TYPE_BUTTON, NULL);
+    drive_button_set_mount (self, mount);
+
+    g_signal_connect (gtk_icon_theme_get_default (),
+        "changed", G_CALLBACK (drive_button_theme_change),
+        self);
+
+    return (GtkWidget *)self;
+}
+
+static void
+drive_button_dispose (GObject *object)
+{
+    DriveButton *self = DRIVE_BUTTON (object);
+
+    drive_button_set_volume (self, NULL);
+
+    if (self->update_tag)
+        g_source_remove (self->update_tag);
+    self->update_tag = 0;
+
+    drive_button_reset_popup (self);
+
+    if (G_OBJECT_CLASS (drive_button_parent_class)->dispose)
+        (* G_OBJECT_CLASS (drive_button_parent_class)->dispose) (object);
+}
+
+static gboolean
+drive_button_button_press (GtkWidget      *widget,
+                           GdkEventButton *event)
+{
+    DriveButton *self = DRIVE_BUTTON (widget);
+
+    /* don't consume non-button1 presses */
+    if (event->button == 1) {
+        drive_button_ensure_popup (self);
+        if (self->popup_menu) {
+            gtk_menu_popup_at_widget (GTK_MENU (self->popup_menu),
+                                      widget,
+                                      GDK_GRAVITY_SOUTH_WEST,
+                                      GDK_GRAVITY_NORTH_WEST,
+                                      (const GdkEvent*) event);
+        }
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static gboolean
+drive_button_key_press (GtkWidget      *widget,
+                        GdkEventKey    *event)
+{
+    DriveButton *self = DRIVE_BUTTON (widget);
+
+    switch (event->keyval) {
+    case GDK_KEY_KP_Space:
+    case GDK_KEY_space:
+    case GDK_KEY_KP_Enter:
+    case GDK_KEY_Return:
+        drive_button_ensure_popup (self);
+        if (self->popup_menu) {
+            gtk_menu_popup_at_widget (GTK_MENU (self->popup_menu),
+                                      widget,
+                                      GDK_GRAVITY_SOUTH_WEST,
+                                      GDK_GRAVITY_NORTH_WEST,
+                                      (const GdkEvent*) event);
+        }
+        return TRUE;
+    }
+    return FALSE;
+}
+
+static void
+drive_button_theme_change (GtkIconTheme *icon_theme,
+                           gpointer      data)
+{
+    drive_button_queue_update (data);
+}
+
+static void
+drive_button_set_volume (DriveButton *self,
+                         GVolume     *volume)
+{
+    g_return_if_fail (DRIVE_IS_BUTTON (self));
+
+    if (self->volume) {
+        g_object_unref (self->volume);
+    }
+    self->volume = NULL;
+    if (self->mount) {
+        g_object_unref (self->mount);
+    }
+    self->mount = NULL;
+
+    if (volume) {
+        self->volume = g_object_ref (volume);
+    }
+    drive_button_queue_update (self);
+}
+
+static void
+drive_button_set_mount (DriveButton *self,
+                        GMount       *mount)
+{
+    g_return_if_fail (DRIVE_IS_BUTTON (self));
+
+    if (self->volume) {
+        g_object_unref (self->volume);
+    }
+    self->volume = NULL;
+    if (self->mount) {
+        g_object_unref (self->mount);
+    }
+    self->mount = NULL;
+
+    if (mount) {
+        self->mount = g_object_ref (mount);
+    }
+    drive_button_queue_update (self);
+}
+
+static gboolean
+drive_button_update (gpointer user_data)
+{
+    DriveButton *self;
+    GdkScreen *screen;
+    GtkIconTheme *icon_theme;
+    GtkIconInfo *icon_info;
+    GIcon *icon;
+    int width, height, scale;
+    cairo_t *cr;
+    cairo_surface_t *surface = NULL;
+    cairo_surface_t *tmp_surface = NULL;
+    GtkRequisition button_req, image_req;
+    char *display_name, *tip;
+
+    g_return_val_if_fail (DRIVE_IS_BUTTON (user_data), FALSE);
+    self = DRIVE_BUTTON (user_data);
+    self->update_tag = 0;
+
+    /* base the icon size on the desired button size */
+    drive_button_reset_popup (self);
+    scale = gtk_widget_get_scale_factor (GTK_WIDGET (self));
+    gtk_widget_get_preferred_size (GTK_WIDGET (self), NULL, &button_req);
+    gtk_widget_get_preferred_size (gtk_bin_get_child (GTK_BIN (self)), NULL, &image_req);
+    width = (self->icon_size - (button_req.width - image_req.width)) / scale;
+    height = (self->icon_size - (button_req.height - image_req.height)) / scale;
+
+    /* if no volume or mount, display general image */
+    if (!self->volume && !self->mount)
+    {
+        gtk_widget_set_tooltip_text (GTK_WIDGET (self), _("nothing to mount"));
+        screen = gtk_widget_get_screen (GTK_WIDGET (self));
+        icon_theme = gtk_icon_theme_get_for_screen (screen); //m
+        // note - other good icon would be emblem-unreadable
+        icon_info = gtk_icon_theme_lookup_icon_for_scale (icon_theme, "media-floppy",
+                                                          MIN (width, height), scale,
+                                                          GTK_ICON_LOOKUP_USE_BUILTIN);
+        if (icon_info) {
+            surface = gtk_icon_info_load_surface (icon_info, NULL, NULL);
+            g_object_unref (icon_info);
+        }
+
+        if (!surface)
+            return FALSE;
+
+        if (gtk_bin_get_child (GTK_BIN (self)) != NULL)
+            gtk_image_set_from_surface (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (self))), surface);
+
+        return FALSE;
+    }
+
+    gboolean is_mounted = FALSE;
+
+    if (self->volume)
+    {
+        GMount *mount;
+
+        display_name = g_volume_get_name (self->volume);
+        mount = g_volume_get_mount (self->volume);
+
+        if (mount)
+        {
+            is_mounted = TRUE;
+            tip = g_strdup_printf ("%s\n%s", display_name, _("(mounted)"));
+            icon = g_mount_get_icon (mount);
+            g_object_unref (mount);
+        }
+        else
+        {
+            is_mounted = FALSE;
+            tip = g_strdup_printf ("%s\n%s", display_name, _("(not mounted)"));
+            icon = g_volume_get_icon (self->volume);
+        }
+    } else
+    {
+        is_mounted = TRUE;
+        display_name = g_mount_get_name (self->mount);
+        tip = g_strdup_printf ("%s\n%s", display_name, _("(mounted)"));
+        icon = g_mount_get_icon (self->mount);
+    }
+
+    gtk_widget_set_tooltip_text (GTK_WIDGET (self), tip);
+    g_free (tip);
+    g_free (display_name);
+
+    screen = gtk_widget_get_screen (GTK_WIDGET (self));
+    icon_theme = gtk_icon_theme_get_for_screen (screen);
+    icon_info = gtk_icon_theme_lookup_by_gicon_for_scale (icon_theme, icon,
+                                                          MIN (width, height), scale,
+                                                          GTK_ICON_LOOKUP_USE_BUILTIN);
+    if (icon_info)
+    {
+        surface = gtk_icon_info_load_surface (icon_info, NULL, NULL);
+        g_object_unref (icon_info);
+    }
+
+    g_object_unref (icon);
+
+    if (!surface)
+        return FALSE;
+
+    // create a new surface because icon image can be shared by system
+    tmp_surface = cairo_surface_create_similar (surface,
+                                                cairo_surface_get_content (surface),
+                                                cairo_image_surface_get_width (surface) / scale,
+                                                cairo_image_surface_get_height (surface) / scale);
+
+    // if mounted, change icon
+    if (is_mounted)
+    {
+        int icon_width, icon_height, rowstride, n_channels, x, y;
+        guchar *pixels, *p;
+        gboolean has_alpha;
+
+        has_alpha = cairo_surface_get_content (tmp_surface) != CAIRO_CONTENT_COLOR;
+        n_channels = 3;
+        if (has_alpha)
+            n_channels++;
+
+        icon_width = cairo_image_surface_get_width (tmp_surface);
+        icon_height = cairo_image_surface_get_height (tmp_surface);
+
+        rowstride = cairo_image_surface_get_stride (tmp_surface);
+        pixels = cairo_image_surface_get_data (tmp_surface);
+
+        GdkRGBA color;
+        GSettings *settings;
+        settings = g_settings_new ("org.mate.drivemount");
+        gchar *color_string = g_settings_get_string (settings, "drivemount-checkmark-color");
+        if (!color_string)
+                color_string = g_strdup ("#00ff00");
+        gdk_rgba_parse (&color, color_string);
+        g_free (color_string);
+        g_object_unref (settings);
+
+        guchar red = color.red*255;
+        guchar green = color.green*255;
+        guchar blue = color.blue*255;
+
+        const gdouble ratio = 0.65;
+        gdouble y_start = icon_height * ratio;
+        gdouble x_start = icon_height * (1 + ratio);
+
+        for (y = y_start; y < icon_height; y++)
+            for (x = x_start - y; x < icon_width; x++)
+            {
+                p = pixels + y * rowstride + x * n_channels;
+                p[0] = red;
+                p[1] = green;
+                p[2] = blue;
+                if (has_alpha)
+                    p[3] = 255;
+            }
+    }
+
+    cr = cairo_create (tmp_surface);
+    cairo_set_operator (cr, CAIRO_OPERATOR_OVERLAY);
+    cairo_set_source_surface (cr, surface, 0, 0);
+    cairo_paint (cr);
+
+    gtk_image_set_from_surface (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (self))), tmp_surface);
+
+    cairo_surface_destroy (surface);
+    cairo_surface_destroy (tmp_surface);
+
+    gtk_widget_get_preferred_size (GTK_WIDGET (self), NULL, &button_req);
+
+    return FALSE;
+}
+
+void
+drive_button_queue_update (DriveButton *self)
+{
+    if (!self->update_tag) {
+        self->update_tag = g_idle_add (drive_button_update, self);
+    }
+}
+
+void
+drive_button_set_size (DriveButton *self,
+                       int icon_size)
+{
+    g_return_if_fail (DRIVE_IS_BUTTON (self));
+
+    if (self->icon_size != icon_size) {
+        self->icon_size = icon_size;
+        drive_button_queue_update (self);
+    }
+}
+
+void
+drive_button_redraw (gpointer key,
+                     gpointer value,
+                     gpointer user_data)
+{
+    DriveButton *button = value;
+    drive_button_queue_update (button);
+}
+
+int
+drive_button_compare (DriveButton *button,
+                      DriveButton *other_button)
+{
+    /* sort drives before driveless volumes volumes */
+    if (button->volume) {
+        if (other_button->volume) {
+            int cmp;
+            gchar *str1, *str2;
+
+            str1 = g_volume_get_name (button->volume);
+            str2 = g_volume_get_name (other_button->volume);
+            cmp = g_utf8_collate (str1, str2);
+            g_free (str2);
+            g_free (str1);
+
+            return cmp;
+        } else {
+            return -1;
+        }
+    } else {
+        if (other_button->volume) {
+            return 1;
+        } else {
+            int cmp;
+            gchar *str1, *str2;
+
+            str1 = g_mount_get_name (button->mount);
+            str2 = g_mount_get_name (other_button->mount);
+            cmp = g_utf8_collate (str1, str2);
+            g_free (str2);
+            g_free (str1);
+
+            return cmp;
+        }
+    }
+}
+
+static void
+drive_button_reset_popup (DriveButton *self)
+{
+    if (self->popup_menu)
+        gtk_widget_destroy (GTK_WIDGET (self->popup_menu));
+    self->popup_menu = NULL;
+}
+
+#if 0
+static void
+popup_menu_detach (GtkWidget *attach_widget, GtkMenu *menu)
+{
+    DRIVE_BUTTON (attach_widget)->popup_menu = NULL;
+}
+#endif /* 0 */
+
+static char *
+escape_underscores (const char *str)
+{
+    char *new_str;
+    int i, j, count;
+
+    /* count up how many underscores are in the string */
+    count = 0;
+    for (i = 0; str[i] != '\0'; i++) {
+        if (str[i] == '_')
+            count++;
+    }
+    /* copy to new string, doubling up underscores */
+    new_str = g_new (char, i + count + 1);
+    for (i = j = 0; str[i] != '\0'; i++, j++) {
+        new_str[j] = str[i];
+        if (str[i] == '_')
+            new_str[++j] = '_';
+    }
+    new_str[j] = '\0';
+    return new_str;
+}
+static GtkWidget *
+create_menu_item (DriveButton *self,
+                  const gchar *icon_name,
+                  const gchar *label,
+                  GCallback    callback,
+                  gboolean     sensitive)
+{
+    GtkWidget *item, *image;
+
+    item = gtk_image_menu_item_new_with_mnemonic (label);
+    if (icon_name) {
+        image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
+        gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
+        gtk_widget_show (image);
+    }
+    if (callback)
+        g_signal_connect_object (item, "activate", callback, self,
+                                 G_CONNECT_SWAPPED);
+    gtk_widget_set_sensitive (item, sensitive);
+    gtk_widget_show (item);
+    return item;
+}
+
+static void
+open_drive (DriveButton *self,
+            GtkWidget   *item)
+{
+    GdkScreen *screen;
+    GtkWidget *dialog;
+    GError *error = NULL;
+    GFile *file = NULL;
+    GList *files = NULL;
+    GdkAppLaunchContext *launch_context;
+    GAppInfo *app_info;
+
+    if (self->volume) {
+        GMount *mount;
+
+        mount = g_volume_get_mount (self->volume);
+        if (mount) {
+            file = g_mount_get_root (mount);
+            g_object_unref (mount);
+        }
+    } else if (self->mount) {
+        file = g_mount_get_root (self->mount);
+    } else
+        g_return_if_reached ();
+
+    app_info = g_app_info_get_default_for_type ("inode/directory", FALSE);
+    if (!app_info)
+      app_info = G_APP_INFO (g_desktop_app_info_new ("caja.desktop"));
+
+    if (app_info) {
+        GdkDisplay *display = gtk_widget_get_display (item);
+        launch_context = gdk_display_get_app_launch_context (display);
+        screen = gtk_widget_get_screen (GTK_WIDGET (self));
+        gdk_app_launch_context_set_screen (launch_context, screen);
+        files = g_list_prepend (files, file);
+        g_app_info_launch (app_info,
+        files,
+        G_APP_LAUNCH_CONTEXT (launch_context),
+        &error);
+
+        g_object_unref (launch_context);
+        g_list_free (files);
+    }
+
+    if (!app_info || error) {
+        dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (self))),
+                                                     GTK_DIALOG_DESTROY_WITH_PARENT,
+                                                     GTK_MESSAGE_ERROR,
+                                                     GTK_BUTTONS_OK,
+                                                     _("Cannot execute Caja"));
+        if (error)
+            gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", error->message);
+        else
+            gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "Could not find Caja");
+        g_signal_connect (dialog, "response",
+                          G_CALLBACK (gtk_widget_destroy), NULL);
+        gtk_widget_show (dialog);
+        g_error_free (error);
+    }
+
+    g_object_unref (file);
+}
+
+/* copied from mate-volume-manager/src/manager.c maybe there is a better way than
+ * duplicating this code? */
+
+/*
+ * gvm_run_command - run the given command, replacing %d with the device node
+ * and %m with the given path
+ */
+static void
+gvm_run_command (const char *device,
+                 const char *command,
+                 const char *path)
+{
+    char *argv[4];
+    gchar *new_command;
+    GError *error = NULL;
+    GString *exec = g_string_new (NULL);
+    char *p, *q;
+
+    /* perform s/%d/device/ and s/%m/path/ */
+    new_command = g_strdup (command);
+    q = new_command;
+    p = new_command;
+    while ((p = strchr (p, '%')) != NULL) {
+        if (*(p + 1) == 'd') {
+            *p = '\0';
+            g_string_append (exec, q);
+            g_string_append (exec, device);
+            q = p + 2;
+            p = p + 2;
+        } else if (*(p + 1) == 'm') {
+            *p = '\0';
+            g_string_append (exec, q);
+            g_string_append (exec, path);
+            q = p + 2;
+            p = p + 2;
+        } else {
+            /* Ignore anything else. */
+            p++;
+        }
+    }
+    g_string_append (exec, q);
+
+    argv[0] = "/bin/sh";
+    argv[1] = "-c";
+    argv[2] = exec->str;
+    argv[3] = NULL;
+
+    g_spawn_async (g_get_home_dir (), argv, NULL, 0, NULL, NULL,
+                   NULL, &error);
+    if (error) {
+        g_warning ("failed to exec %s: %s\n", exec->str, error->message);
+        g_error_free (error);
+    }
+
+    g_string_free (exec, TRUE);
+    g_free (new_command);
+}
+
+/*
+ * gvm_check_dvd_only - is this a Video DVD?
+ *
+ * Returns TRUE if this was a Video DVD and FALSE otherwise.
+ * (the original in gvm was also running the autoplay action,
+ * I removed that code, so I renamed from gvm_check_dvd to
+ * gvm_check_dvd_only)
+ */
+static gboolean
+gvm_check_dvd_only (const char *udi,
+                    const char *device,
+                    const char *mount_point)
+{
+    char *path;
+    gboolean retval;
+
+    path = g_build_path (G_DIR_SEPARATOR_S, mount_point, "video_ts", NULL);
+    retval = g_file_test (path, G_FILE_TEST_IS_DIR);
+    g_free (path);
+
+    /* try the other name, if needed */
+    if (retval == FALSE) {
+        path = g_build_path (G_DIR_SEPARATOR_S, mount_point,
+                             "VIDEO_TS", NULL);
+        retval = g_file_test (path, G_FILE_TEST_IS_DIR);
+        g_free (path);
+    }
+
+    return retval;
+}
+/* END copied from mate-volume-manager/src/manager.c */
+
+static gboolean
+check_dvd_video (DriveButton *self)
+{
+    GFile *file;
+    char *udi, *device_path, *mount_path;
+    gboolean result;
+    GMount *mount;
+
+    if (!self->volume)
+        return FALSE;
+
+    mount = g_volume_get_mount (self->volume);
+    if (!mount)
+        return FALSE;
+
+    file = g_mount_get_root (mount);
+    g_object_unref (mount);
+
+    if (!file)
+        return FALSE;
+
+    mount_path = g_file_get_path (file);
+
+    g_object_unref (file);
+
+    device_path = g_volume_get_identifier (self->volume,
+                                           G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
+    udi = g_volume_get_identifier (self->volume,
+                                   G_VOLUME_IDENTIFIER_KIND_HAL_UDI);
+
+    result = gvm_check_dvd_only (udi, device_path, mount_path);
+
+    g_free (device_path);
+    g_free (udi);
+    g_free (mount_path);
+
+    return result;
+}
+
+static gboolean
+check_audio_cd (DriveButton *self)
+{
+    GFile *file;
+    char *activation_uri;
+    GMount *mount;
+
+    if (!self->volume)
+        return FALSE;
+
+    mount = g_volume_get_mount (self->volume);
+    if (!mount)
+        return FALSE;
+
+    file = g_mount_get_root (mount);
+    g_object_unref (mount);
+
+    if (!file)
+        return FALSE;
+
+    activation_uri = g_file_get_uri (file);
+
+    g_object_unref (file);
+
+    /* we have an audioCD if the activation URI starts by 'cdda://' */
+    gboolean result = (strncmp ("cdda://", activation_uri, 7) == 0);
+    g_free (activation_uri);
+    return result;
+}
+
+static void
+run_command (DriveButton *self,
+             const char  *command)
+{
+    GFile *file;
+    char *mount_path, *device_path;
+    GMount *mount;
+
+    if (!self->volume)
+        return;
+
+    mount = g_volume_get_mount (self->volume);
+    if (!mount)
+        return;
+
+    file = g_mount_get_root (mount);
+    g_object_unref (mount);
+
+    g_assert (file);
+
+    mount_path = g_file_get_path (file);
+
+    g_object_unref (file);
+
+    device_path = g_volume_get_identifier (self->volume,
+                                           G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
+
+    gvm_run_command (device_path, command, mount_path);
+
+    g_free (mount_path);
+    g_free (device_path);
+}
+
+static void dummy_async_ready_callback (GObject      *source_object,
+                                        GAsyncResult *res,
+                                        gpointer      user_data)
+{
+    /* do nothing */
+}
+
+static void
+mount_drive (DriveButton *self,
+             GtkWidget   *item)
+{
+    if (self->volume) {
+        GMountOperation *mount_op = gtk_mount_operation_new (NULL);
+        g_volume_mount (self->volume, G_MOUNT_MOUNT_NONE,
+                        mount_op, NULL, dummy_async_ready_callback, NULL);
+        g_object_unref (mount_op);
+    } else {
+        g_return_if_reached ();
+    }
+}
+
+static void
+unmount_drive (DriveButton *self,
+               GtkWidget   *item)
+{
+    if (self->volume) {
+        GMount *mount;
+
+        mount = g_volume_get_mount (self->volume);
+        if (mount) {
+            g_mount_unmount_with_operation (mount, G_MOUNT_UNMOUNT_NONE,
+                                            NULL, NULL, dummy_async_ready_callback, NULL);
+            g_object_unref (mount);
+        }
+    } else if (self->mount) {
+        g_mount_unmount_with_operation (self->mount, G_MOUNT_UNMOUNT_NONE,
+                                        NULL, NULL, dummy_async_ready_callback, NULL);
+    } else {
+        g_return_if_reached ();
+    }
+}
+
+static void eject_finish (DriveButton  *self,
+                          GAsyncResult *res,
+                          gpointer      user_data)
+{
+    /* Do nothing. We shouldn't need this according to the GIO
+     * docs, but the applet crashes without it using glib 2.18.0 */
+}
+
+static void
+eject_drive (DriveButton *self,
+             GtkWidget   *item)
+{
+    if (self->volume) {
+        g_volume_eject_with_operation (self->volume, G_MOUNT_UNMOUNT_NONE,
+                                       NULL, NULL,
+                                       (GAsyncReadyCallback) eject_finish,
+                                       NULL);
+    } else if (self->mount) {
+        g_mount_eject_with_operation (self->mount, G_MOUNT_UNMOUNT_NONE,
+                                      NULL, NULL,
+                                      (GAsyncReadyCallback) eject_finish,
+                                      NULL);
+    } else {
+        g_return_if_reached ();
+    }
+}
+static void
+play_autoplay_media (DriveButton *self,
+                     const char  *dflt)
+{
+    run_command (self, dflt);
+}
+
+static void
+play_dvd (DriveButton *self,
+          GtkWidget   *item)
+{
+    /* FIXME add an option to set this */
+    play_autoplay_media (self, "totem %d");
+}
+
+static void
+play_cda (DriveButton *self,
+          GtkWidget   *item)
+{
+    /* FIXME add an option to set this */
+    play_autoplay_media (self, "sound-juicer -d %d");
+}
+
+static void
+drive_button_ensure_popup (DriveButton *self)
+{
+    char *display_name, *tmp, *label;
+    GtkWidget *item;
+    gboolean mounted, ejectable;
+
+    if (self->popup_menu) return;
+
+    mounted = FALSE;
+
+    if (self->volume) {
+        GMount *mount = NULL;
+
+        display_name = g_volume_get_name (self->volume);
+        ejectable = g_volume_can_eject (self->volume);
+
+        mount = g_volume_get_mount (self->volume);
+        if (mount) {
+            mounted = TRUE;
+            g_object_unref (mount);
+        }
+    } else {
+        if (!G_IS_MOUNT (self->volume))
+            return;
+        else {
+            display_name = g_mount_get_name (self->mount);
+            ejectable = g_mount_can_eject (self->mount);
+            mounted = TRUE;
+        }
+    }
+
+    self->popup_menu = gtk_menu_new ();
+
+    /* make sure the display name doesn't look like a mnemonic */
+    tmp = escape_underscores (display_name ? display_name : "(none)");
+    g_free (display_name);
+    display_name = tmp;
+
+    if (check_dvd_video (self)) {
+        item = create_menu_item (self, "media-playback-start",
+                                 _("_Play DVD"), G_CALLBACK (play_dvd),
+                                 TRUE);
+    } else if (check_audio_cd (self)) {
+        item = create_menu_item (self, "media-playback-start",
+                                 _("_Play CD"), G_CALLBACK (play_cda),
+                                 TRUE);
+    } else {
+        label = g_strdup_printf (_("_Open %s"), display_name);
+        item = create_menu_item (self, "document-open", label,
+                                 G_CALLBACK (open_drive), mounted);
+        g_free (label);
+    }
+    gtk_container_add (GTK_CONTAINER (self->popup_menu), item);
+
+    if (mounted) {
+        label = g_strdup_printf (_("Un_mount %s"), display_name);
+        item = create_menu_item (self, NULL, label,
+                                 G_CALLBACK (unmount_drive), TRUE);
+        g_free (label);
+        gtk_container_add (GTK_CONTAINER (self->popup_menu), item);
+    } else {
+        label = g_strdup_printf (_("_Mount %s"), display_name);
+        item = create_menu_item (self, NULL, label,
+                                 G_CALLBACK (mount_drive), TRUE);
+        g_free (label);
+        gtk_container_add (GTK_CONTAINER (self->popup_menu), item);
+    }
+
+    if (ejectable) {
+        label = g_strdup_printf (_("_Eject %s"), display_name);
+        item = create_menu_item (self, "media-eject", label,
+                                 G_CALLBACK (eject_drive), TRUE);
+        g_free (label);
+        gtk_container_add (GTK_CONTAINER (self->popup_menu), item);
+    }
+
+    /*Set up custom theme and transparency support */
+    GtkWidget *toplevel = gtk_widget_get_toplevel (self->popup_menu);
+    /* Fix any failures of compiz/other wm's to communicate with gtk for transparency */
+    GdkScreen *screen2 = gtk_widget_get_screen (GTK_WIDGET (toplevel));
+    GdkVisual *visual = gdk_screen_get_rgba_visual (screen2);
+    gtk_widget_set_visual (GTK_WIDGET (toplevel), visual);
+    /*set menu and it's toplevel window to follow panel theme */
+    GtkStyleContext *context;
+    context = gtk_widget_get_style_context (GTK_WIDGET (toplevel));
+    gtk_style_context_add_class (context,"gnome-panel-menu-bar");
+    gtk_style_context_add_class (context,"mate-panel-menu-bar");
+}
diff --git a/drivemount/src/drive-button.h b/drivemount/src/drive-button.h
new file mode 100644
index 00000000..fdab2f16
--- /dev/null
+++ b/drivemount/src/drive-button.h
@@ -0,0 +1,71 @@
+/* -*- mode: C; c-basic-offset: 4 -*-
+ * Drive Mount Applet
+ * Copyright (c) 2004 Canonical Ltd
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author:
+ *   James Henstridge <[email protected]>
+ */
+
+#ifndef DRIVE_BUTTON_H
+#define DRIVE_BUTTON_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define DRIVE_TYPE_BUTTON         (drive_button_get_type ())
+#define DRIVE_BUTTON(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), DRIVE_TYPE_BUTTON, DriveButton))
+#define DRIVE_BUTTON_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), DRIVE_TYPE_BUTTON, DriveButtonClass))
+#define DRIVE_IS_BUTTON(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), DRIVE_TYPE_BUTTON))
+#define DRIVE_IS_BUTTON_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), DRIVE_TYPE_BUTTON))
+#define DRIVE_BUTTON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), DRIVE_TYPE_BUTTON, DriveButtonClass))
+
+typedef struct _DriveButton      DriveButton;
+typedef struct _DriveButtonClass DriveButtonClass;
+
+struct _DriveButton
+{
+    GtkButton parent;
+
+    GVolume *volume;
+    GMount *mount;
+    int icon_size;
+    guint update_tag;
+
+    GtkWidget *popup_menu;
+};
+
+struct _DriveButtonClass
+{
+    GtkButtonClass parent;
+};
+
+GType      drive_button_get_type        (void);
+GtkWidget *drive_button_new             (GVolume *volume);
+GtkWidget *drive_button_new_from_mount  (GMount *mount);
+void       drive_button_queue_update    (DriveButton *button);
+void       drive_button_set_size        (DriveButton *button,
+                                         int          icon_size);
+
+int        drive_button_compare         (DriveButton *button,
+                                         DriveButton *other_button);
+
+void       drive_button_redraw (gpointer key, gpointer value, gpointer user_data);
+
+G_END_DECLS
+
+#endif /* DRIVE_BUTTON_H */
diff --git a/drivemount/src/drive-list.c b/drivemount/src/drive-list.c
new file mode 100644
index 00000000..b1840051
--- /dev/null
+++ b/drivemount/src/drive-list.c
@@ -0,0 +1,522 @@
+/* -*- mode: C; c-basic-offset: 4 -*-
+ * Drive Mount Applet
+ * Copyright (c) 2004 Canonical Ltd
+ * Copyright 2008 Pierre Ossman
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author:
+ *   James Henstridge <[email protected]>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gio/gio.h>
+#include "drive-list.h"
+#include "drive-button.h"
+#include <glib/gi18n.h>
+
+G_DEFINE_TYPE (DriveList, drive_list, GTK_TYPE_GRID);
+
+static GVolumeMonitor *volume_monitor = NULL;
+
+static void drive_list_finalize (GObject *object);
+static void drive_list_dispose  (GObject *object);
+static void drive_list_add      (GtkContainer *container, GtkWidget *child);
+static void drive_list_remove   (GtkContainer *container, GtkWidget *child);
+
+static void mount_added         (GVolumeMonitor *monitor, GMount *mount, DriveList *self);
+static void mount_changed       (GVolumeMonitor *monitor, GMount *mount, DriveList *self);
+static void mount_removed       (GVolumeMonitor *monitor, GMount *mount, DriveList *self);
+static void volume_added        (GVolumeMonitor *monitor, GVolume *volume, DriveList *self);
+static void volume_changed      (GVolumeMonitor *monitor, GVolume *volume, DriveList *self);
+static void volume_removed      (GVolumeMonitor *monitor, GVolume *volume, DriveList *self);
+static void add_volume          (DriveList *self, GVolume *volume);
+static void remove_volume       (DriveList *self, GVolume *volume);
+static void add_mount           (DriveList *self, GMount *mount);
+static void remove_mount        (DriveList *self, GMount *mount);
+static void queue_relayout      (DriveList *self);
+
+static void
+drive_list_class_init (DriveListClass *class)
+{
+    G_OBJECT_CLASS (class)->finalize = drive_list_finalize;
+    G_OBJECT_CLASS (class)->dispose = drive_list_dispose;
+    GTK_CONTAINER_CLASS (class)->add = drive_list_add;
+    GTK_CONTAINER_CLASS (class)->remove = drive_list_remove;
+}
+
+static void
+drive_list_init (DriveList *self)
+{
+    GList *volumes, *mounts, *tmp;
+
+    gtk_grid_set_column_homogeneous (GTK_GRID (self), TRUE);
+    gtk_grid_set_row_homogeneous (GTK_GRID (self), TRUE);
+
+    self->volumes = g_hash_table_new (NULL, NULL);
+    self->mounts = g_hash_table_new (NULL, NULL);
+    self->orientation = GTK_ORIENTATION_HORIZONTAL;
+    self->layout_tag = 0;
+    self->settings = g_settings_new ("org.mate.drivemount");
+    self->icon_size = 24;
+    self->relief = GTK_RELIEF_NORMAL;
+
+    g_signal_connect (self->settings,
+                      "changed::drivemount-checkmark-color",
+                      G_CALLBACK (settings_color_changed),
+                      self);
+
+    /* listen for drive connects/disconnects, and add
+     * currently connected drives. */
+    self->count = 0;
+    if (!volume_monitor)
+        volume_monitor = g_volume_monitor_get ();
+
+    g_signal_connect_object (volume_monitor, "mount_added",
+                             G_CALLBACK (mount_added), self, 0);
+    g_signal_connect_object (volume_monitor, "mount_changed",
+                             G_CALLBACK (mount_changed), self, 0);
+    g_signal_connect_object (volume_monitor, "mount_removed",
+                             G_CALLBACK (mount_removed), self, 0);
+    g_signal_connect_object (volume_monitor, "volume_added",
+                             G_CALLBACK (volume_added), self, 0);
+    g_signal_connect_object (volume_monitor, "volume_changed",
+                             G_CALLBACK (volume_changed), self, 0);
+    g_signal_connect_object (volume_monitor, "volume_removed",
+                             G_CALLBACK (volume_removed), self, 0);
+    volumes = g_volume_monitor_get_volumes (volume_monitor);
+    for (tmp = volumes; tmp != NULL; tmp = tmp->next) {
+        GVolume *volume = tmp->data;
+        add_volume (self, volume);
+        g_object_unref (volume);
+        self->count++;
+    }
+    g_list_free (volumes);
+
+    mounts = g_volume_monitor_get_mounts (volume_monitor);
+    for (tmp = mounts; tmp != NULL; tmp = tmp->next) {
+        GMount *mount = tmp->data;
+        add_mount (self, mount);
+        g_object_unref (mount);
+        self->count++;
+    }
+    self->dummy = drive_button_new (NULL);
+    gtk_button_set_relief (GTK_BUTTON (self->dummy), self->relief);
+    drive_button_set_size (DRIVE_BUTTON (self->dummy), self->icon_size);
+
+    if (self->count == 0) {
+        gtk_container_add (GTK_CONTAINER (self), self->dummy);
+        queue_relayout (self);
+        drive_button_queue_update (DRIVE_BUTTON (self->dummy));
+    }
+    g_list_free (mounts);
+}
+
+GtkWidget *
+drive_list_new (void)
+{
+    return g_object_new (DRIVE_TYPE_LIST, NULL);
+}
+
+static void
+drive_list_finalize (GObject *object)
+{
+    DriveList *self = DRIVE_LIST (object);
+
+    g_hash_table_destroy (self->volumes);
+    g_hash_table_destroy (self->mounts);
+    g_object_unref (self->settings);
+
+    if (G_OBJECT_CLASS (drive_list_parent_class)->finalize)
+        (* G_OBJECT_CLASS (drive_list_parent_class)->finalize) (object);
+}
+
+static void
+drive_list_dispose (GObject *object)
+{
+    DriveList *self = DRIVE_LIST (object);
+
+    g_signal_handlers_disconnect_by_func (volume_monitor,
+                                          G_CALLBACK (mount_added), self);
+    g_signal_handlers_disconnect_by_func (volume_monitor,
+                                          G_CALLBACK (mount_changed), self);
+    g_signal_handlers_disconnect_by_func (volume_monitor,
+                                          G_CALLBACK (mount_removed), self);
+    g_signal_handlers_disconnect_by_func (volume_monitor,
+                                          G_CALLBACK (volume_added), self);
+    g_signal_handlers_disconnect_by_func (volume_monitor,
+                                          G_CALLBACK (volume_changed), self);
+    g_signal_handlers_disconnect_by_func (volume_monitor,
+                                          G_CALLBACK (volume_removed), self);
+
+    if (self->layout_tag)
+        g_source_remove (self->layout_tag);
+    self->layout_tag = 0;
+
+    if (G_OBJECT_CLASS (drive_list_parent_class)->dispose)
+        (* G_OBJECT_CLASS (drive_list_parent_class)->dispose) (object);
+}
+
+static void
+drive_list_add (GtkContainer *container,
+                GtkWidget    *child)
+{
+    DriveList *self;
+    DriveButton *button;
+
+    g_return_if_fail (DRIVE_IS_LIST (container));
+    g_return_if_fail (DRIVE_IS_BUTTON (child));
+
+    if (GTK_CONTAINER_CLASS (drive_list_parent_class)->add)
+        (* GTK_CONTAINER_CLASS (drive_list_parent_class)->add) (container, child);
+
+    self = DRIVE_LIST (container);
+    button = DRIVE_BUTTON (child);
+    if (button->volume)
+        g_hash_table_insert (self->volumes, button->volume, button);
+    else
+        g_hash_table_insert (self->mounts, button->mount, button);
+}
+
+static void
+drive_list_remove (GtkContainer *container,
+                   GtkWidget    *child)
+{
+    DriveList *self;
+    DriveButton *button;
+
+    g_return_if_fail (DRIVE_IS_LIST (container));
+    g_return_if_fail (DRIVE_IS_BUTTON (child));
+
+    self = DRIVE_LIST (container);
+    button = DRIVE_BUTTON (child);
+    if (button->volume)
+        g_hash_table_remove (self->volumes, button->volume);
+    else
+        g_hash_table_remove (self->mounts, button->mount);
+
+    if (GTK_CONTAINER_CLASS (drive_list_parent_class)->remove)
+        (* GTK_CONTAINER_CLASS (drive_list_parent_class)->remove) (container, child);
+}
+
+static void
+list_buttons (gpointer key,
+              gpointer value,
+              gpointer user_data)
+{
+    GtkWidget *button = value;
+    GList **sorted_buttons = user_data;
+
+    *sorted_buttons = g_list_insert_sorted (*sorted_buttons, button,
+                                            (GCompareFunc)drive_button_compare);
+}
+
+static gboolean
+relayout_buttons (gpointer data)
+{
+    DriveList *self = DRIVE_LIST (data);
+    GList *sorted_buttons = NULL, *tmp;
+    int i = 0;
+
+    self->layout_tag = 0;
+    if ( self->count > 0 ) {
+        g_hash_table_foreach (self->volumes, list_buttons, &sorted_buttons);
+        g_hash_table_foreach (self->mounts, list_buttons, &sorted_buttons);
+
+        /* position buttons in the table according to their sorted order */
+        for (tmp = sorted_buttons, i = 0; tmp != NULL; tmp = tmp->next, i++) {
+            GtkWidget *button = tmp->data;
+
+            if (self->orientation == GTK_ORIENTATION_HORIZONTAL) {
+                gtk_container_child_set (GTK_CONTAINER (self), button,
+                                         "left-attach", i + 1, "top-attach", 0,
+                                         "width", 1, "height", 1,
+                                         NULL);
+            }
+            else {
+                gtk_container_child_set (GTK_CONTAINER (self), button,
+                                         "left-attach", 0, "top-attach", i + 1,
+                                         "width", 1, "height", 1,
+                                         NULL);
+            }
+        }
+    }
+    else {
+        gtk_widget_show (self->dummy);
+        if (self->orientation == GTK_ORIENTATION_HORIZONTAL) {
+            gtk_container_child_set (GTK_CONTAINER (self), self->dummy,
+                                     "left-attach", i + 1, "top-attach", 0,
+                                     "width", 1, "height", 1,
+                                     NULL);
+        }
+        else {
+            gtk_container_child_set (GTK_CONTAINER (self), self->dummy,
+                                     "left-attach", 0, "top-attach", i + 1,
+                                     "width", 1, "height", 1,
+                                     NULL);
+        }
+    }
+    return FALSE;
+}
+
+static void
+queue_relayout (DriveList *self)
+{
+    if (!self->layout_tag) {
+        self->layout_tag = g_idle_add (relayout_buttons, self);
+    }
+}
+
+static void
+mount_added (GVolumeMonitor *monitor,
+             GMount         *mount,
+             DriveList      *self)
+{
+    add_mount (self, mount);
+    self->count++;
+    if (self->count == 1)
+        gtk_container_remove (GTK_CONTAINER (self), g_object_ref (self->dummy));
+
+    mount_changed (monitor, mount, self);
+}
+
+static void
+mount_changed (GVolumeMonitor *monitor,
+               GMount         *mount,
+               DriveList      *self)
+{
+    GVolume *volume;
+    DriveButton *button = NULL;;
+
+    volume = g_mount_get_volume (mount);
+    if (volume) {
+        button = g_hash_table_lookup (self->volumes, volume);
+        g_object_unref (volume);
+    } else {
+        button = g_hash_table_lookup (self->mounts, mount);
+    }
+    if (button)
+        drive_button_queue_update (button);
+}
+
+static void
+mount_removed (GVolumeMonitor *monitor,
+               GMount         *mount,
+               DriveList      *self)
+{
+    remove_mount (self, mount);
+    mount_changed (monitor, mount, self);
+    self->count--;
+    if (self->count == 0) {
+        gtk_container_add (GTK_CONTAINER (self), self->dummy);
+        queue_relayout (self);
+    }
+}
+
+static void
+volume_added (GVolumeMonitor *monitor,
+              GVolume        *volume,
+              DriveList      *self)
+{
+    add_volume (self, volume);
+    self->count++;
+    if (self->count == 1)
+        gtk_container_remove (GTK_CONTAINER (self), g_object_ref (self->dummy));
+}
+
+static void
+volume_changed (GVolumeMonitor *monitor,
+                GVolume        *volume,
+                DriveList      *self)
+{
+    DriveButton *button = NULL;;
+
+    button = g_hash_table_lookup (self->volumes, volume);
+    if (button)
+        drive_button_queue_update (button);
+}
+
+static void
+volume_removed (GVolumeMonitor *monitor,
+                GVolume        *volume,
+                DriveList      *self)
+{
+    remove_volume (self, volume);
+    self->count--;
+    if (self->count == 0) {
+        gtk_container_add (GTK_CONTAINER (self), self->dummy);
+        queue_relayout (self);
+    }
+}
+
+static void
+add_volume (DriveList *self,
+            GVolume   *volume)
+{
+    GtkWidget *button;
+
+    /* if the volume has already been added, return */
+    if (g_hash_table_lookup (self->volumes, volume) != NULL)
+        return;
+
+    button = drive_button_new (volume);
+    gtk_button_set_relief (GTK_BUTTON (button), self->relief);
+    drive_button_set_size (DRIVE_BUTTON (button), self->icon_size);
+    gtk_container_add (GTK_CONTAINER (self), button);
+    gtk_widget_show (button);
+    queue_relayout (self);
+}
+
+static void
+remove_volume (DriveList *self,
+               GVolume   *volume)
+{
+    GtkWidget *button;
+
+    /* if the volume has already been added, return */
+    button = g_hash_table_lookup (self->volumes, volume);
+    if (button) {
+        gtk_container_remove (GTK_CONTAINER (self), button);
+        queue_relayout (self);
+    }
+}
+
+static void
+add_mount (DriveList *self,
+           GMount    *mount)
+{
+    GtkWidget *button;
+    GVolume *volume;
+
+    /* ignore mounts reported as shadowed */
+    if (g_mount_is_shadowed (mount)) {
+        return;
+    }
+
+    /* ignore mounts attached to a volume */
+    volume = g_mount_get_volume (mount);
+    if (volume) {
+        g_object_unref (volume);
+        return;
+    }
+
+    /* if the mount has already been added, return */
+    if (g_hash_table_lookup (self->mounts, mount) != NULL)
+        return;
+
+    button = drive_button_new_from_mount (mount);
+    gtk_button_set_relief (GTK_BUTTON (button), self->relief);
+    drive_button_set_size (DRIVE_BUTTON (button), self->icon_size);
+    gtk_container_add (GTK_CONTAINER (self), button);
+    gtk_widget_show (button);
+    queue_relayout (self);
+}
+
+static void
+remove_mount (DriveList *self,
+              GMount    *mount)
+{
+    GtkWidget *button;
+
+    /* if the mount has already been added, return */
+    button = g_hash_table_lookup (self->mounts, mount);
+    if (button) {
+        gtk_container_remove (GTK_CONTAINER (self), button);
+        queue_relayout (self);
+    }
+}
+
+void
+drive_list_set_orientation (DriveList      *self,
+                            GtkOrientation  orientation)
+{
+    g_return_if_fail (DRIVE_IS_LIST (self));
+
+    if (orientation != self->orientation) {
+        self->orientation = orientation;
+        queue_relayout (self);
+    }
+}
+
+static void
+set_icon_size (gpointer key,
+               gpointer value,
+               gpointer user_data)
+{
+    DriveButton *button = value;
+    DriveList *self = user_data;
+
+    drive_button_set_size (button, self->icon_size);
+}
+
+
+void
+drive_list_set_panel_size (DriveList *self,
+                           int        panel_size)
+{
+    g_return_if_fail (DRIVE_IS_LIST (self));
+
+    if (self->icon_size != panel_size) {
+        self->icon_size = panel_size;
+        g_hash_table_foreach (self->volumes, set_icon_size, self);
+        g_hash_table_foreach (self->mounts, set_icon_size, self);
+    }
+}
+
+void
+drive_list_redraw (DriveList *self)
+{
+    g_hash_table_foreach (self->volumes, drive_button_redraw, self);
+    g_hash_table_foreach (self->mounts, drive_button_redraw, self);
+}
+
+void
+settings_color_changed (GSettings *settings,
+                        gchar     *key,
+                        DriveList *drive_list)
+{
+    g_return_if_fail (DRIVE_IS_LIST (drive_list));
+    drive_list_redraw (drive_list);
+}
+
+static void
+set_button_relief (gpointer key,
+                   gpointer value,
+                   gpointer user_data)
+{
+    GtkButton *button = value;
+    DriveList *self = user_data;
+
+    gtk_button_set_relief (button, self->relief);
+}
+
+void
+drive_list_set_transparent (DriveList *self,
+                            gboolean   transparent)
+{
+    GtkReliefStyle relief;
+
+    relief  = transparent ? GTK_RELIEF_NONE : GTK_RELIEF_NORMAL;
+
+    if (relief == self->relief)
+        return;
+
+    self->relief = relief;
+    g_hash_table_foreach (self->volumes, set_button_relief, self);
+    g_hash_table_foreach (self->mounts, set_button_relief, self);
+}
diff --git a/drivemount/src/drive-list.h b/drivemount/src/drive-list.h
new file mode 100644
index 00000000..e2da7333
--- /dev/null
+++ b/drivemount/src/drive-list.h
@@ -0,0 +1,73 @@
+/* -*- mode: C; c-basic-offset: 4 -*-
+ * Drive Mount Applet
+ * Copyright (c) 2004 Canonical Ltd
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author:
+ *   James Henstridge <[email protected]>
+ */
+
+#ifndef DRIVE_LIST_H
+#define DRIVE_LIST_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define DRIVE_TYPE_LIST         (drive_list_get_type ())
+#define DRIVE_LIST(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), DRIVE_TYPE_LIST, DriveList))
+#define DRIVE_LIST_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), DRIVE_TYPE_LIST, DriveListClass))
+#define DRIVE_IS_LIST(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), DRIVE_TYPE_LIST))
+#define DRIVE_IS_LIST_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), DRIVE_TYPE_LIST))
+#define DRIVE_LIST_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), DRIVE_TYPE_LIST, DriveListClass))
+
+typedef struct _DriveList      DriveList;
+typedef struct _DriveListClass DriveListClass;
+
+struct _DriveList
+{
+    GtkGrid parent;
+
+    GHashTable *volumes;
+    GHashTable *mounts;
+    GtkOrientation orientation;
+    guint layout_tag;
+    GtkReliefStyle relief;
+    GtkWidget *dummy;
+    gint count;
+
+    GSettings *settings;
+
+    int icon_size;
+};
+
+struct _DriveListClass
+{
+    GtkGridClass parent_class;
+};
+
+GType      drive_list_get_type (void);
+GtkWidget *drive_list_new (void);
+void       drive_list_set_orientation (DriveList *list,
+                                       GtkOrientation orientation);
+void       drive_list_set_panel_size  (DriveList *list,
+                                       int panel_size);
+void       drive_list_set_transparent (DriveList *self,
+                                       gboolean transparent);
+void       drive_list_redraw (DriveList *self);
+void       settings_color_changed (GSettings *settings, gchar *key, DriveList *drive_list);
+
+#endif /* DRIVE_LIST_H */
diff --git a/drivemount/src/drivemount.c b/drivemount/src/drivemount.c
new file mode 100644
index 00000000..d6a77f20
--- /dev/null
+++ b/drivemount/src/drivemount.c
@@ -0,0 +1,230 @@
+/* -*- mode: C; c-basic-offset: 4 -*-
+ * Drive Mount Applet
+ * Copyright (c) 2004 Canonical Ltd
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author:
+ *   James Henstridge <[email protected]>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <string.h>
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include <mate-panel-applet.h>
+
+#include "drive-list.h"
+
+static const char drivemount_iid[] = "DriveMountApplet";
+static const char factory_iid[] = "DriveMountAppletFactory";
+
+static void
+change_orient (MatePanelApplet *applet,
+               MatePanelAppletOrient o,
+               DriveList *drive_list)
+{
+    GtkOrientation orientation;
+
+    switch (o) {
+        case MATE_PANEL_APPLET_ORIENT_LEFT:
+        case MATE_PANEL_APPLET_ORIENT_RIGHT:
+            orientation = GTK_ORIENTATION_VERTICAL;
+            break;
+        case MATE_PANEL_APPLET_ORIENT_UP:
+        case MATE_PANEL_APPLET_ORIENT_DOWN:
+        default:
+            orientation = GTK_ORIENTATION_HORIZONTAL;
+    }
+    drive_list_set_orientation (drive_list, orientation);
+}
+
+static void
+size_allocate (MatePanelApplet *applet,
+               GdkRectangle    *allocation,
+               DriveList       *drive_list)
+{
+    int size;
+
+    switch (mate_panel_applet_get_orient (applet)) {
+        case MATE_PANEL_APPLET_ORIENT_LEFT:
+        case MATE_PANEL_APPLET_ORIENT_RIGHT:
+            size = allocation->width;
+            break;
+        case MATE_PANEL_APPLET_ORIENT_UP:
+        case MATE_PANEL_APPLET_ORIENT_DOWN:
+        default:
+            size = allocation->height;
+    }
+    drive_list_set_panel_size (drive_list, size);
+}
+
+static void
+change_background (MatePanelApplet               *applet,
+                   MatePanelAppletBackgroundType  type,
+                   GdkColor                      *colour,
+                   cairo_pattern_t               *pattern,
+                   DriveList                     *drivelist)
+{
+    switch (type) {
+        case PANEL_NO_BACKGROUND:
+            drive_list_set_transparent (drivelist, FALSE);
+            break;
+        case PANEL_COLOR_BACKGROUND:
+        case PANEL_PIXMAP_BACKGROUND:
+            drive_list_set_transparent (drivelist, TRUE);
+    }
+}
+
+static void
+display_about_dialog (GtkAction *action,
+                      DriveList *drive_list)
+{
+    const gchar *authors[] = {
+        "James Henstridge <[email protected]>",
+        NULL
+    };
+
+    const gchar *documenters[] = {
+        "Dan Mueth <[email protected]>",
+        "John Fleck <[email protected]>",
+        N_("MATE Documentation Team"),
+        NULL
+    };
+
+#ifdef ENABLE_NLS
+    const char **p;
+    for (p = documenters; *p; ++p)
+        *p = _(*p);
+#endif
+
+    gtk_show_about_dialog (NULL,
+                           "title",              _("About Disk Mounter"),
+                           "version",            VERSION,
+                           "copyright",          _("Copyright \xC2\xA9 2004 Canonical Ltd\n"
+                                                   "Copyright \xc2\xa9 2012-2020 MATE developers"),
+                           "comments",           _("Applet for mounting and unmounting block volumes."),
+                           "authors",            authors,
+                           "documenters",        documenters,
+                           "translator-credits", _("translator-credits"),
+                           "logo_icon_name",     "media-floppy",
+                           NULL);
+}
+
+static void
+display_help (GtkAction *action,
+              DriveList *drive_list)
+{
+    GdkScreen *screen;
+    GError *error = NULL;
+
+    screen = gtk_widget_get_screen (GTK_WIDGET (drive_list));
+
+    gtk_show_uri_on_window (NULL,
+                            "help:mate-drivemount",
+                            gtk_get_current_event_time (),
+                            &error);
+
+    if (error) {
+        GtkWidget *dialog;
+
+        dialog = gtk_message_dialog_new (NULL,
+                                         GTK_DIALOG_MODAL,
+                                         GTK_MESSAGE_ERROR,
+                                         GTK_BUTTONS_OK,
+                                         _("There was an error displaying help: %s"),
+                                         error->message);
+        g_signal_connect (dialog, "response",
+                          G_CALLBACK (gtk_widget_destroy), NULL);
+        gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
+        gtk_window_set_screen (GTK_WINDOW (dialog), screen);
+        gtk_widget_show (dialog);
+        g_error_free (error);
+    }
+}
+
+static const GtkActionEntry applet_menu_actions[] = {
+    { "Help", "help-browser", N_("_Help"),
+      NULL, NULL,
+      G_CALLBACK (display_help) },
+    { "About", "help-about", N_("_About"),
+      NULL, NULL,
+      G_CALLBACK (display_about_dialog) }
+};
+
+static gboolean
+applet_factory (MatePanelApplet *applet,
+                const char      *iid,
+                gpointer         user_data)
+{
+    gboolean ret = FALSE;
+    GtkWidget *drive_list;
+    AtkObject *ao;
+    GtkActionGroup *action_group;
+
+    if (!strcmp (iid, drivemount_iid)) {
+        g_set_application_name (_("Disk Mounter"));
+
+        gtk_window_set_default_icon_name ("media-floppy");
+
+        mate_panel_applet_set_flags (applet, MATE_PANEL_APPLET_EXPAND_MINOR);
+
+        drive_list = drive_list_new ();
+
+        gtk_container_add (GTK_CONTAINER (applet), drive_list);
+
+        g_signal_connect_object (applet, "change_orient",
+                                 G_CALLBACK (change_orient), drive_list, 0);
+        g_signal_connect_object (applet, "size_allocate",
+                                 G_CALLBACK (size_allocate), drive_list, 0);
+        g_signal_connect (applet, "change_background",
+                          G_CALLBACK (change_background), drive_list);
+
+        /* set initial state */
+        change_orient (applet,
+                       mate_panel_applet_get_orient (applet),
+                       DRIVE_LIST (drive_list));
+
+        action_group = gtk_action_group_new ("DriveMount Applet Actions");
+        gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
+        gtk_action_group_add_actions (action_group,
+                                      applet_menu_actions,
+                                      G_N_ELEMENTS (applet_menu_actions),
+                                      drive_list);
+        mate_panel_applet_setup_menu_from_resource (applet,
+                                                    DRIVEMOUNT_RESOURCE_PATH "drivemount-applet-menu.xml",
+                                                    action_group);
+        g_object_unref (action_group);
+
+        ao = gtk_widget_get_accessible (GTK_WIDGET (applet));
+        atk_object_set_name (ao, _("Disk Mounter"));
+
+        gtk_widget_show_all (GTK_WIDGET (applet));
+
+        ret = TRUE;
+    }
+
+    return ret;
+}
+
+MATE_PANEL_APPLET_OUT_PROCESS_FACTORY (factory_iid,
+                                       PANEL_TYPE_APPLET,
+                                       "Drive-Mount-Applet",
+                                       applet_factory, NULL)
+