[gtk+/wip/gbsneto/other-locations: 1/3] placesview: add view for fixed drives and networks

[Georges Basile Stavracas Neto <gbsneto src gnome org>]

commit 857c03f30605889616e211f4bacf4f4f0357b3d0
Author: Georges Basile Stavracas Neto <georges stavracas gmail com>
Date:   Tue Jul 14 14:45:37 2015 -0300

    placesview: add view for fixed drives and networks
    
    Places sidebar shows XDG directories, mounted and unmounted devices,
    connected networks, bookmarks and actions like 'Connect to server'
    and 'Insert location', which causes the sidebar to grow very quickly
    and look cluttered. Because of that, new mockups for the sidebar try
    to simplify it.
    
    To make the sidebar simpler, the new mockups propose that it should
    only handle connected networks and removable devices such as flash
    drives and USB devices, and delegates other devices for external
    widgets through the 'Other Locations' item.
    
    To handle fixed devices and manage network connections, add a new
    widget named GtkPlacesView, based on Nautilus mockups to keep
    consistency between GNOME file management tools - in this case,
    between Nautilus and the bundled Gtk's file chooser.
    
    https://bugzilla.gnome.org/show_bug.cgi?id=752034

 gtk/Makefile.am               |    6 +
 gtk/gtkplacesview.c           | 1961 +++++++++++++++++++++++++++++++++++++++++
 gtk/gtkplacesviewprivate.h    |   93 ++
 gtk/gtkplacesviewrow.c        |  246 ++++++
 gtk/gtkplacesviewrowprivate.h |   51 ++
 gtk/ui/gtkplacesview.ui       |  503 +++++++++++
 gtk/ui/gtkplacesviewrow.ui    |  107 +++
 tests/Makefile.am             |    5 +
 tests/testplacesview.c        |   24 +
 9 files changed, 2996 insertions(+), 0 deletions(-)
---
diff --git a/gtk/Makefile.am b/gtk/Makefile.am
index 4795f84..7f8b72b 100644
--- a/gtk/Makefile.am
+++ b/gtk/Makefile.am
@@ -476,6 +476,8 @@ gtk_private_h_sources =             \
        gtkpango.h              \
        gtkpathbar.h            \
        gtkplacessidebarprivate.h       \
+       gtkplacesviewprivate.h  \
+       gtkplacesviewrowprivate.h       \
        gtkpopoverprivate.h     \
        gtkprintoperation-private.h \
        gtkprintutils.h         \
@@ -757,6 +759,8 @@ gtk_base_c_sources =                \
        gtkpapersize.c          \
        gtkpathbar.c            \
        gtkplacessidebar.c      \
+       gtkplacesview.c         \
+       gtkplacesviewrow.c      \
        gtkprintcontext.c       \
        gtkprintoperation.c     \
        gtkprintoperationpreview.c \
@@ -1087,6 +1091,8 @@ templates =                               \
        ui/gtkmessagedialog.ui  \
        ui/gtkpagesetupunixdialog.ui    \
        ui/gtkpathbar.ui                \
+       ui/gtkplacesview.ui             \
+       ui/gtkplacesviewrow.ui          \
        ui/gtkprintunixdialog.ui        \
        ui/gtkrecentchooserdefault.ui   \
        ui/gtksearchbar.ui              \
diff --git a/gtk/gtkplacesview.c b/gtk/gtkplacesview.c
new file mode 100644
index 0000000..87b59d6
--- /dev/null
+++ b/gtk/gtkplacesview.c
@@ -0,0 +1,1961 @@
+/* gtkplacesview.c
+ *
+ * Copyright (C) 2015 Georges Basile Stavracas Neto <georges stavracas gmail com>
+ *
+ * This program 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gio/gio.h>
+#include <gtk/gtk.h>
+
+#include "gtkintl.h"
+#include "gtkmarshalers.h"
+#include "gtkplacesviewprivate.h"
+#include "gtkplacesviewrowprivate.h"
+#include "gtktypebuiltins.h"
+
+/**
+ * SECTION:gtkplacesview
+ * @Short_description: Widget that displays persistent drives and manages mounted networks
+ * @Title: GtkPlacesView
+ * @See_also: #GtkFileChooser
+ *
+ * #GtkPlacesView is a stock widget that displays a list of persistent drives
+ * such as harddisk partitions and networks.  #GtkPlacesView does not monitor
+ * removable devices.
+ *
+ * The places view displays drives and networks, and will automatically mount
+ * them when the user activates. Network addresses are stored even if they fail
+ * to connect. When the connection is successful, the connected network is
+ * shown at the network list.
+ *
+ * To make use of the places view, an application at least needs to connect
+ * to the #GtkPlacesView::open-location signal. This is emitted when the user
+ * selects a location to open in the view.
+ */
+
+struct _GtkPlacesViewPrivate
+{
+  GVolumeMonitor                *volume_monitor;
+  GtkPlacesOpenFlags             open_flags;
+  GtkPlacesOpenFlags             current_open_flags;
+
+  GFile                         *server_list_file;
+  GFileMonitor                  *server_list_monitor;
+
+  GCancellable                  *cancellable;
+
+  gchar                         *search_query;
+
+  GtkWidget                     *actionbar;
+  GtkWidget                     *address_entry;
+  GtkWidget                     *connect_button;
+  GtkWidget                     *drives_box;
+  GtkWidget                     *drives_listbox;
+  GtkWidget                     *network_grid;
+  GtkWidget                     *network_listbox;
+  GtkWidget                     *popup_menu;
+  GtkWidget                     *recent_servers_listbox;
+  GtkWidget                     *recent_servers_popover;
+  GtkWidget                     *recent_servers_stack;
+  GtkWidget                     *stack;
+
+  GtkEntryCompletion            *address_entry_completion;
+  GtkListStore                  *completion_store;
+
+  guint                          local_only : 1;
+  guint                          should_open_location : 1;
+  guint                          should_pulse_entry : 1;
+  guint                          entry_pulse_timeout_id;
+};
+
+static void        mount_volume                                  (GtkPlacesView *view,
+                                                                  GVolume       *volume);
+
+static gboolean    on_button_press_event                         (GtkPlacesViewRow *row,
+                                                                  GdkEventButton   *event);
+
+static void        on_eject_button_clicked                       (GtkWidget        *widget,
+                                                                  GtkPlacesViewRow *row);
+
+static gboolean    on_row_popup_menu                             (GtkPlacesViewRow *row);
+
+static void        populate_servers                              (GtkPlacesView *view);
+
+G_DEFINE_TYPE_WITH_PRIVATE (GtkPlacesView, gtk_places_view, GTK_TYPE_BOX)
+
+/* GtkPlacesView properties & signals */
+enum {
+  PROP_0,
+  PROP_LOCAL_ONLY,
+  PROP_OPEN_FLAGS,
+  LAST_PROP
+};
+
+enum {
+  OPEN_LOCATION,
+  SHOW_ERROR_MESSAGE,
+  LAST_SIGNAL
+};
+
+const gchar *unsupported_protocols [] =
+{
+  "file", "afc", "obex", "http",
+  "trash", "burn", "computer",
+  "archive", "recent", "localtest",
+  NULL
+};
+
+static guint places_view_signals [LAST_SIGNAL] = { 0 };
+static GParamSpec *properties [LAST_PROP];
+
+static void
+emit_open_location (GtkPlacesView      *view,
+                    GFile              *location,
+                    GtkPlacesOpenFlags  open_flags)
+{
+  GtkPlacesViewPrivate *priv;
+
+  priv = gtk_places_view_get_instance_private (view);
+
+  if ((open_flags & priv->open_flags) == 0)
+    open_flags = GTK_PLACES_OPEN_NORMAL;
+
+  g_signal_emit (view, places_view_signals[OPEN_LOCATION], 0, location, open_flags);
+}
+
+static void
+emit_show_error_message (GtkPlacesView *view,
+                         gchar         *primary_message,
+                         gchar         *secondary_message)
+{
+  g_signal_emit (view, places_view_signals[SHOW_ERROR_MESSAGE],
+                         0, primary_message, secondary_message);
+}
+
+static void
+server_file_changed_cb (GtkPlacesView *view)
+{
+  populate_servers (view);
+}
+
+static GBookmarkFile *
+server_list_load (GtkPlacesView *view)
+{
+  GtkPlacesViewPrivate *priv;
+  GBookmarkFile *bookmarks;
+  GError *error = NULL;
+  gchar *datadir;
+  gchar *filename;
+
+  priv = gtk_places_view_get_instance_private (view);
+  bookmarks = g_bookmark_file_new ();
+  datadir = g_build_filename (g_get_user_config_dir (), "gtk-3.0", NULL);
+  filename = g_build_filename (datadir, "servers", NULL);
+
+  g_mkdir_with_parents (datadir, 0700);
+  g_bookmark_file_load_from_file (bookmarks, filename, &error);
+
+  if (error)
+    {
+      if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
+        {
+          /* only warn if the file exists */
+          g_warning ("Unable to open server bookmarks: %s", error->message);
+          g_clear_pointer (&bookmarks, g_bookmark_file_free);
+        }
+
+      g_clear_error (&error);
+    }
+
+  /* Monitor the file in case it's modified outside this code */
+  if (!priv->server_list_monitor)
+    {
+      priv->server_list_file = g_file_new_for_path (filename);
+
+      if (priv->server_list_file)
+        {
+          priv->server_list_monitor = g_file_monitor_file (priv->server_list_file,
+                                                           G_FILE_MONITOR_NONE,
+                                                           NULL,
+                                                           &error);
+
+          if (error)
+            {
+              g_warning ("Cannot monitor server file: %s", error->message);
+              g_clear_error (&error);
+            }
+          else
+            {
+              g_signal_connect_swapped (priv->server_list_monitor,
+                                        "changed",
+                                        G_CALLBACK (server_file_changed_cb),
+                                        view);
+            }
+        }
+
+      g_clear_object (&priv->server_list_file);
+    }
+
+  g_free (datadir);
+  g_free (filename);
+
+  return bookmarks;
+}
+
+static void
+server_list_save (GBookmarkFile *bookmarks)
+{
+  gchar *filename;
+
+  filename = g_build_filename (g_get_user_config_dir (), "gtk-3.0", "servers", NULL);
+  g_bookmark_file_to_file (bookmarks, filename, NULL);
+  g_free (filename);
+}
+
+static void
+server_list_add_server (GtkPlacesView *view,
+                        GFile         *file)
+{
+  GBookmarkFile *bookmarks;
+  GFileInfo *info;
+  GError *error;
+  gchar *title;
+  gchar *uri;
+
+  error = NULL;
+  bookmarks = server_list_load (view);
+
+  if (!bookmarks)
+    return;
+
+  uri = g_file_get_uri (file);
+
+  info = g_file_query_info (file,
+                            G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
+                            G_FILE_QUERY_INFO_NONE,
+                            NULL,
+                            &error);
+  title = g_file_info_get_attribute_as_string (info, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME);
+
+  g_bookmark_file_set_title (bookmarks, uri, title);
+  g_bookmark_file_set_visited (bookmarks, uri, -1);
+  g_bookmark_file_add_application (bookmarks, uri, NULL, NULL);
+
+  server_list_save (bookmarks);
+
+  g_bookmark_file_free (bookmarks);
+  g_clear_object (&info);
+  g_free (title);
+  g_free (uri);
+}
+
+static void
+server_list_remove_server (GtkPlacesView *view,
+                           const gchar   *uri)
+{
+  GBookmarkFile *bookmarks;
+
+  bookmarks = server_list_load (view);
+
+  if (!bookmarks)
+    return;
+
+  g_bookmark_file_remove_item (bookmarks, uri, NULL);
+  server_list_save (bookmarks);
+
+  g_bookmark_file_free (bookmarks);
+}
+
+/* Returns a toplevel GtkWindow, or NULL if none */
+static GtkWindow *
+get_toplevel (GtkWidget *widget)
+{
+  GtkWidget *toplevel;
+
+  toplevel = gtk_widget_get_toplevel (widget);
+  if (!gtk_widget_is_toplevel (toplevel))
+    return NULL;
+  else
+    return GTK_WINDOW (toplevel);
+}
+
+static void
+set_busy_cursor (GtkPlacesView *view,
+                 gboolean       busy)
+{
+  GtkWidget *widget;
+  GtkWindow *toplevel;
+  GdkDisplay *display;
+  GdkCursor *cursor;
+
+  toplevel = get_toplevel (GTK_WIDGET (view));
+  widget = GTK_WIDGET (toplevel);
+  if (!toplevel || !gtk_widget_get_realized (widget))
+    return;
+
+  display = gtk_widget_get_display (widget);
+
+  if (busy)
+    {
+      cursor = gdk_cursor_new_from_name (display, "left_ptr_watch");
+      if (cursor == NULL)
+        cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
+    }
+  else
+    cursor = NULL;
+
+  gdk_window_set_cursor (gtk_widget_get_window (widget), cursor);
+  gdk_display_flush (display);
+
+  if (cursor)
+    g_object_unref (cursor);
+}
+
+/* Activates the given row, with the given flags as parameter */
+static void
+activate_row (GtkPlacesView      *view,
+              GtkPlacesViewRow   *row,
+              GtkPlacesOpenFlags  flags)
+{
+  GtkPlacesViewPrivate *priv;
+  GVolume *volume;
+  GMount *mount;
+
+  priv = gtk_places_view_get_instance_private (view);
+  mount = gtk_places_view_row_get_mount (row);
+  volume = gtk_places_view_row_get_volume (row);
+
+  if (mount)
+    {
+      GFile *location = g_mount_get_root (mount);
+
+      emit_open_location (view, location, GTK_PLACES_OPEN_NORMAL);
+
+      g_object_unref (location);
+    }
+  else if (volume && g_volume_can_mount (volume))
+    {
+      /*
+       * When the row is activated, the unmounted volume shall
+       * be mounted and opened right after.
+       */
+      priv->should_open_location = TRUE;
+
+      gtk_places_view_row_set_busy (row, TRUE);
+      mount_volume (view, volume);
+    }
+}
+
+static void
+gtk_places_view_finalize (GObject *object)
+{
+  GtkPlacesView *self = (GtkPlacesView *)object;
+  GtkPlacesViewPrivate *priv = gtk_places_view_get_instance_private (self);
+
+  if (priv->entry_pulse_timeout_id > 0)
+    g_source_remove (priv->entry_pulse_timeout_id);
+
+  g_cancellable_cancel (priv->cancellable);
+
+  g_clear_pointer (&priv->search_query, g_free);
+  g_clear_object (&priv->server_list_file);
+  g_clear_object (&priv->server_list_monitor);
+  g_clear_object (&priv->volume_monitor);
+  g_clear_object (&priv->cancellable);
+
+  G_OBJECT_CLASS (gtk_places_view_parent_class)->finalize (object);
+}
+
+static void
+gtk_places_view_get_property (GObject    *object,
+                              guint       prop_id,
+                              GValue     *value,
+                              GParamSpec *pspec)
+{
+  GtkPlacesView *self = GTK_PLACES_VIEW (object);
+
+  switch (prop_id)
+    {
+    case PROP_LOCAL_ONLY:
+      g_value_set_boolean (value, gtk_places_view_get_local_only (self));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtk_places_view_set_property (GObject      *object,
+                              guint         prop_id,
+                              const GValue *value,
+                              GParamSpec   *pspec)
+{
+  GtkPlacesView *self = GTK_PLACES_VIEW (object);
+
+  switch (prop_id)
+    {
+    case PROP_LOCAL_ONLY:
+      gtk_places_view_set_local_only (self, g_value_get_boolean (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static gboolean
+is_removable_volume (GVolume *volume)
+{
+  gboolean is_removable;
+  GDrive *drive;
+  GMount *mount;
+  gchar *id;
+
+  drive = g_volume_get_drive (volume);
+  mount = g_volume_get_mount (volume);
+  id = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_CLASS);
+
+  is_removable = g_volume_can_eject (volume);
+
+  /* NULL volume identifier only happens on removable devices */
+  is_removable |= !id;
+
+  if (drive)
+    is_removable |= g_drive_can_eject (drive);
+
+  if (mount)
+    is_removable |= (g_mount_can_eject (mount) && !g_mount_can_unmount (mount));
+
+  g_clear_object (&drive);
+  g_clear_object (&mount);
+  g_free (id);
+
+  return is_removable;
+}
+
+typedef struct
+{
+  gchar         *uri;
+  GtkPlacesView *view;
+} RemoveServerData;
+
+static void
+on_remove_server_button_clicked (RemoveServerData *data)
+{
+  server_list_remove_server (data->view, data->uri);
+
+  populate_servers (data->view);
+}
+
+static void
+populate_servers (GtkPlacesView *view)
+{
+  GtkPlacesViewPrivate *priv;
+  GBookmarkFile *server_list;
+  GList *children;
+  gchar **uris;
+  gsize num_uris;
+  gint i;
+
+  priv = gtk_places_view_get_instance_private (view);
+  server_list = server_list_load (view);
+
+  if (!server_list)
+    return;
+
+
+  uris = g_bookmark_file_get_uris (server_list, &num_uris);
+
+  gtk_stack_set_visible_child_name (GTK_STACK (priv->recent_servers_stack),
+                                    num_uris > 0 ? "list" : "empty");
+
+  if (!uris)
+    {
+      g_bookmark_file_free (server_list);
+      return;
+    }
+
+  /* clear previous items */
+  children = gtk_container_get_children (GTK_CONTAINER (priv->recent_servers_listbox));
+  g_list_free_full (children, (GDestroyNotify) gtk_widget_destroy);
+
+  gtk_list_store_clear (priv->completion_store);
+
+  for (i = 0; i < num_uris; i++)
+    {
+      RemoveServerData *data;
+      GtkTreeIter iter;
+      GtkWidget *row;
+      GtkWidget *grid;
+      GtkWidget *button;
+      GtkWidget *label;
+      gchar *name;
+      gchar *dup_uri;
+
+      name = g_bookmark_file_get_title (server_list, uris[i], NULL);
+      dup_uri = g_strdup (uris[i]);
+
+      /* add to the completion list */
+      gtk_list_store_append (priv->completion_store, &iter);
+      gtk_list_store_set (priv->completion_store,
+                          &iter,
+                          0, name,
+                          1, uris[i],
+                          -1);
+
+      /* add to the recent servers listbox */
+      row = gtk_list_box_row_new ();
+
+      grid = g_object_new (GTK_TYPE_GRID,
+                           "orientation", GTK_ORIENTATION_VERTICAL,
+                           "border-width", 6,
+                           NULL);
+
+      /* name of the connected uri, if any */
+      label = gtk_label_new (name);
+      gtk_widget_set_hexpand (label, TRUE);
+      gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+      gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
+      gtk_container_add (GTK_CONTAINER (grid), label);
+
+      /* the uri itself */
+      label = gtk_label_new (uris[i]);
+      gtk_widget_set_hexpand (label, TRUE);
+      gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+      gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
+      gtk_style_context_add_class (gtk_widget_get_style_context (label), "dim-label");
+      gtk_container_add (GTK_CONTAINER (grid), label);
+
+      /* remove button */
+      button = gtk_button_new ();
+      gtk_widget_set_halign (button, GTK_ALIGN_END);
+      gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
+      gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
+      gtk_style_context_add_class (gtk_widget_get_style_context (button), "image-button");
+      gtk_style_context_add_class (gtk_widget_get_style_context (button), "sidebar-button");
+      gtk_grid_attach (GTK_GRID (grid), button, 1, 0, 1, 2);
+      gtk_container_add (GTK_CONTAINER (button),
+                         gtk_image_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_BUTTON));
+
+      gtk_container_add (GTK_CONTAINER (row), grid);
+      gtk_container_add (GTK_CONTAINER (priv->recent_servers_listbox), row);
+
+      /* custom data */
+      data = g_new0 (RemoveServerData, 1);
+      data->view = view;
+      data->uri = dup_uri;
+
+      g_object_set_data_full (G_OBJECT (row), "uri", dup_uri, g_free);
+      g_object_set_data_full (G_OBJECT (row), "remove-server-data", data, g_free);
+
+      g_signal_connect_swapped (button,
+                                "clicked",
+                                G_CALLBACK (on_remove_server_button_clicked),
+                                data);
+
+      gtk_widget_show_all (row);
+
+      g_free (name);
+    }
+
+  g_strfreev (uris);
+  g_bookmark_file_free (server_list);
+}
+
+static void
+update_search_widgets (GtkPlacesView *view)
+{
+  GtkPlacesViewPrivate *priv;
+  GList *children;
+  GList *l;
+  gint visible_drives;
+  gint visible_networks;
+
+  priv = gtk_places_view_get_instance_private (view);
+  visible_drives = 0;
+  visible_networks = 0;
+
+  /* drives */
+  children = gtk_container_get_children (GTK_CONTAINER (priv->drives_listbox));
+
+  for (l = children; l; l = l->next)
+    visible_drives += gtk_widget_get_child_visible (l->data);
+
+  g_list_free (children);
+
+  /* networks */
+  children = gtk_container_get_children (GTK_CONTAINER (priv->network_listbox));
+
+  for (l = children; l; l = l->next)
+    visible_networks += gtk_widget_get_child_visible (l->data);
+
+  g_list_free (children);
+
+  gtk_widget_set_visible (priv->drives_box, visible_drives != 0);
+  gtk_widget_set_visible (priv->network_grid, visible_networks != 0);
+
+  if (visible_drives == 0 && visible_networks == 0)
+    gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "search");
+  else
+    gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "lists");
+}
+
+static void
+insert_row (GtkPlacesView *view,
+            GtkWidget     *row,
+            gboolean       is_network)
+{
+  GtkPlacesViewPrivate *priv;
+  GtkWidget *container;
+  GtkWidget *list;
+
+  priv = gtk_places_view_get_instance_private (view);
+  list = is_network ? priv->network_listbox : priv->drives_listbox;
+  container = is_network ? priv->network_grid : priv->drives_box;
+
+  g_signal_connect_swapped (gtk_places_view_row_get_event_box (GTK_PLACES_VIEW_ROW (row)),
+                            "button-press-event",
+                            G_CALLBACK (on_button_press_event),
+                            row);
+
+  g_signal_connect (row,
+                    "popup-menu",
+                    G_CALLBACK (on_row_popup_menu),
+                    row);
+
+  g_signal_connect (gtk_places_view_row_get_eject_button (GTK_PLACES_VIEW_ROW (row)),
+                    "clicked",
+                    G_CALLBACK (on_eject_button_clicked),
+                    row);
+
+  gtk_container_add (GTK_CONTAINER (list), row);
+  gtk_widget_show (container);
+}
+
+static void
+add_volume (GtkPlacesView *view,
+            GVolume       *volume)
+{
+  gboolean is_network;
+  GDrive *drive;
+  GMount *mount;
+  GFile *root;
+  GIcon *icon;
+  gchar *identifier;
+  gchar *name;
+  gchar *path;
+
+  if (is_removable_volume (volume))
+    return;
+
+  drive = g_volume_get_drive (volume);
+
+  if (drive)
+    {
+      gboolean is_removable;
+
+      is_removable = g_drive_is_media_removable (drive) ||
+                     g_volume_can_eject (volume);
+      g_object_unref (drive);
+
+      if (is_removable)
+        return;
+    }
+
+  identifier = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_CLASS);
+  is_network = g_strcmp0 (identifier, "network") == 0;
+
+  mount = g_volume_get_mount (volume);
+  root = mount ? g_mount_get_root (mount) : NULL;
+  icon = g_volume_get_icon (volume);
+  name = g_volume_get_name (volume);
+  path = root ? g_file_get_parse_name (root) : NULL;
+
+  if (!mount ||
+      (mount && !g_mount_is_shadowed (mount)))
+    {
+      GtkWidget *row;
+
+      row = g_object_new (GTK_TYPE_PLACES_VIEW_ROW,
+                      "icon", icon,
+                      "name", name,
+                      "path", path ? path : "",
+                      "volume", volume,
+                      "mount", mount,
+                      NULL);
+
+      insert_row (view, row, is_network);
+    }
+
+  g_clear_object (&root);
+  g_clear_object (&icon);
+  g_clear_object (&mount);
+  g_free (identifier);
+  g_free (name);
+  g_free (path);
+}
+
+static void
+add_mount (GtkPlacesView *view,
+           GMount        *mount)
+{
+  gboolean is_network;
+  GFile *root;
+  GIcon *icon;
+  gchar *name;
+  gchar *path;
+  gchar *uri;
+  gchar *schema;
+
+  icon = g_mount_get_icon (mount);
+  name = g_mount_get_name (mount);
+  root = g_mount_get_root (mount);
+  path = root ? g_file_get_parse_name (root) : NULL;
+  uri = g_file_get_uri (root);
+  schema = g_uri_parse_scheme (uri);
+  is_network = g_strcmp0 (schema, "file") != 0;
+
+  if (!g_mount_is_shadowed (mount))
+    {
+      GtkWidget *row;
+
+      row = g_object_new (GTK_TYPE_PLACES_VIEW_ROW,
+                      "icon", icon,
+                      "name", name,
+                      "path", path ? path : "",
+                      "volume", NULL,
+                      "mount", mount,
+                      NULL);
+
+      insert_row (view, row, is_network);
+    }
+
+  g_clear_object (&root);
+  g_clear_object (&icon);
+  g_free (name);
+  g_free (path);
+  g_free (uri);
+  g_free (schema);
+}
+
+static void
+add_drive (GtkPlacesView *view,
+           GDrive        *drive)
+{
+  GList *volumes;
+  GList *l;
+
+  /* Removable devices won't appear here */
+  if (g_drive_can_eject (drive))
+    return;
+
+  volumes = g_drive_get_volumes (drive);
+
+  for (l = volumes; l != NULL; l = l->next)
+    add_volume (view, l->data);
+
+  g_list_free_full (volumes, g_object_unref);
+}
+
+static void
+update_places (GtkPlacesView *view)
+{
+  GtkPlacesViewPrivate *priv;
+  GList *children;
+  GList *mounts;
+  GList *volumes;
+  GList *drives;
+  GList *l;
+
+  priv = gtk_places_view_get_instance_private (view);
+
+  /* Clear all previously added items */
+  children = gtk_container_get_children (GTK_CONTAINER (priv->drives_listbox));
+  g_list_free_full (children, (GDestroyNotify) gtk_widget_destroy);
+
+  children = gtk_container_get_children (GTK_CONTAINER (priv->network_listbox));
+  g_list_free_full (children, (GDestroyNotify) gtk_widget_destroy);
+
+  /*
+   * Hide both networks and drives lists, and only show them when
+   * a row is added.
+   */
+  gtk_widget_hide (priv->drives_box);
+  gtk_widget_hide (priv->network_grid);
+
+  /* Add currently connected drives */
+  drives = g_volume_monitor_get_connected_drives (priv->volume_monitor);
+
+  for (l = drives; l != NULL; l = l->next)
+    add_drive (view, l->data);
+
+  g_list_free_full (drives, g_object_unref);
+
+  /*
+   * Since all volumes with an associated GDrive were already added with
+   * add_drive before, add all volumes that aren't associated with a
+   * drive.
+   */
+  volumes = g_volume_monitor_get_volumes (priv->volume_monitor);
+
+  for (l = volumes; l != NULL; l = l->next)
+    {
+      GVolume *volume;
+      GDrive *drive;
+
+      volume = l->data;
+      drive = g_volume_get_drive (volume);
+
+      if (drive)
+        {
+          g_object_unref (drive);
+          continue;
+        }
+
+      add_volume (view, volume);
+    }
+
+  g_list_free_full (volumes, g_object_unref);
+
+  /*
+   * Now that all necessary drives and volumes were already added, add mounts
+   * that has no volume, such as /etc/mtab mounts, ftp, sftp, etc.
+   */
+  mounts = g_volume_monitor_get_mounts (priv->volume_monitor);
+
+  for (l = mounts; l != NULL; l = l->next)
+    {
+      GMount *mount;
+      GVolume *volume;
+
+      mount = l->data;
+      volume = g_mount_get_volume (mount);
+
+      if (volume)
+        {
+          g_object_unref (volume);
+          continue;
+        }
+
+      add_mount (view, mount);
+    }
+
+  g_list_free_full (mounts, g_object_unref);
+
+  /* load saved servers */
+  populate_servers (view);
+
+  if (!priv->search_query)
+    {
+      if (!gtk_widget_get_visible (priv->drives_box) &&
+          !gtk_widget_get_visible (priv->network_grid))
+        {
+          gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "empty");
+        }
+      else
+        {
+          gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "lists");
+        }
+    }
+  else if (priv->search_query)
+    {
+      update_search_widgets (view);
+    }
+}
+
+static void
+server_mount_ready_cb (GObject      *source_file,
+                       GAsyncResult *res,
+                       gpointer      user_data)
+{
+  GtkPlacesViewPrivate *priv;
+  GtkPlacesView *view;
+  gboolean should_show;
+  GError *error;
+  GFile *location;
+
+  view = GTK_PLACES_VIEW (user_data);
+  priv = gtk_places_view_get_instance_private (view);
+  location = G_FILE (source_file);
+  should_show = TRUE;
+  error = NULL;
+
+  priv->should_pulse_entry = FALSE;
+  set_busy_cursor (view, FALSE);
+
+  g_file_mount_enclosing_volume_finish (location, res, &error);
+
+  if (error)
+    {
+      should_show = FALSE;
+
+      if (error->code == G_IO_ERROR_ALREADY_MOUNTED)
+        {
+          /*
+           * Already mounted volume is not a critical error
+           * and we can still continue with the operation.
+           */
+          should_show = TRUE;
+        }
+      else if (error->domain != G_IO_ERROR ||
+               (error->code != G_IO_ERROR_CANCELLED &&
+                error->code != G_IO_ERROR_FAILED_HANDLED))
+        {
+          /* if it wasn't cancelled show a dialog */
+          emit_show_error_message (view, _("Unable to access location"), error->message);
+          should_show = FALSE;
+        }
+
+      g_clear_error (&error);
+    }
+
+  if (should_show)
+    {
+      server_list_add_server (view, location);
+
+      /*
+       * Only clear the entry if it successfully connects to the server.
+       * Otherwise, the user would lost the typed address even if it fails
+       * to connect.
+       */
+      gtk_entry_set_text (GTK_ENTRY (priv->address_entry), "");
+
+      if (priv->should_open_location)
+        {
+          emit_open_location (view, location, priv->open_flags);
+        }
+    }
+
+  update_places (view);
+}
+
+static void
+volume_mount_ready_cb (GObject      *source_volume,
+                       GAsyncResult *res,
+                       gpointer      user_data)
+{
+  GtkPlacesViewPrivate *priv;
+  GtkPlacesView *view;
+  gboolean should_show;
+  GVolume *volume;
+  GError *error;
+
+  view = GTK_PLACES_VIEW (user_data);
+  priv = gtk_places_view_get_instance_private (view);
+  volume = G_VOLUME (source_volume);
+  should_show = TRUE;
+  error = NULL;
+
+  set_busy_cursor (view, FALSE);
+
+  g_volume_mount_finish (volume, res, &error);
+
+  if (error)
+    {
+      should_show = FALSE;
+
+      if (error->code == G_IO_ERROR_ALREADY_MOUNTED)
+        {
+          /*
+           * If the volume was already mounted, it's not a hard error
+           * and we can still continue with the operation.
+           */
+          should_show = TRUE;
+        }
+      else if (error->domain != G_IO_ERROR ||
+               (error->code != G_IO_ERROR_CANCELLED &&
+                error->code != G_IO_ERROR_FAILED_HANDLED))
+        {
+          /* if it wasn't cancelled show a dialog */
+          emit_show_error_message (GTK_PLACES_VIEW (user_data), _("Unable to access location"), 
error->message);
+          should_show = FALSE;
+        }
+
+      g_clear_error (&error);
+    }
+
+  if (should_show)
+    {
+      GMount *mount;
+      GFile *root;
+
+      mount = g_volume_get_mount (volume);
+      root = g_mount_get_root (mount);
+
+      if (priv->should_open_location)
+        {
+          emit_open_location (GTK_PLACES_VIEW (user_data), root, priv->open_flags);
+        }
+
+      g_object_unref (mount);
+      g_object_unref (root);
+    }
+
+  update_places (view);
+}
+
+static void
+unmount_ready_cb (GObject      *source_mount,
+                  GAsyncResult *res,
+                  gpointer      user_data)
+{
+  GtkPlacesView *view;
+  GMount *mount;
+  GError *error;
+
+  view = GTK_PLACES_VIEW (user_data);
+  mount = G_MOUNT (source_mount);
+  error = NULL;
+
+  set_busy_cursor (view, FALSE);
+
+  g_mount_unmount_with_operation_finish (mount, res, &error);
+
+  if (error)
+    {
+      if (error->domain != G_IO_ERROR ||
+          (error->code != G_IO_ERROR_CANCELLED &&
+           error->code != G_IO_ERROR_FAILED_HANDLED))
+        {
+          /* if it wasn't cancelled show a dialog */
+          emit_show_error_message (view, _("Unable to unmount volume"), error->message);
+        }
+
+      g_clear_error (&error);
+    }
+}
+
+
+static gboolean
+pulse_entry_cb (gpointer user_data)
+{
+  GtkPlacesViewPrivate *priv;
+
+  priv = gtk_places_view_get_instance_private (GTK_PLACES_VIEW (user_data));
+
+  if (priv->should_pulse_entry)
+    {
+      gtk_entry_progress_pulse (GTK_ENTRY (priv->address_entry));
+
+      return G_SOURCE_CONTINUE;
+    }
+  else
+    {
+      gtk_entry_set_progress_pulse_step (GTK_ENTRY (priv->address_entry), 0.0);
+      gtk_entry_set_progress_fraction (GTK_ENTRY (priv->address_entry), 0.0);
+      priv->entry_pulse_timeout_id = 0;
+
+      return G_SOURCE_REMOVE;
+    }
+}
+
+static void
+unmount_mount (GtkPlacesView *view,
+               GMount        *mount)
+{
+  GtkPlacesViewPrivate *priv;
+  GMountOperation *operation;
+  GtkWidget *toplevel;
+
+  priv = gtk_places_view_get_instance_private (view);
+  toplevel = gtk_widget_get_toplevel (GTK_WIDGET (view));
+  operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
+
+  set_busy_cursor (GTK_PLACES_VIEW (view), TRUE);
+
+  g_cancellable_cancel (priv->cancellable);
+  priv->cancellable = g_cancellable_new ();
+
+  operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
+  g_mount_unmount_with_operation (mount,
+                                  0,
+                                  operation,
+                                  NULL,
+                                  unmount_ready_cb,
+                                  view);
+  g_object_unref (operation);
+}
+
+static void
+mount_server (GtkPlacesView *view,
+              GFile         *location)
+{
+  GtkPlacesViewPrivate *priv;
+  GMountOperation *operation;
+  GtkWidget *toplevel;
+
+  priv = gtk_places_view_get_instance_private (view);
+  toplevel = gtk_widget_get_toplevel (GTK_WIDGET (view));
+  operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
+
+  g_cancellable_cancel (priv->cancellable);
+  priv->cancellable = g_cancellable_new ();
+
+  set_busy_cursor (view, TRUE);
+  priv->should_pulse_entry = TRUE;
+  gtk_entry_set_progress_pulse_step (GTK_ENTRY (priv->address_entry), 0.1);
+  priv->entry_pulse_timeout_id = g_timeout_add (100, (GSourceFunc) pulse_entry_cb, view);
+
+  g_mount_operation_set_password_save (operation, G_PASSWORD_SAVE_FOR_SESSION);
+
+  g_file_mount_enclosing_volume (location,
+                                 0,
+                                 operation,
+                                 priv->cancellable,
+                                 server_mount_ready_cb,
+                                 view);
+
+  /* unref operation here - g_file_mount_enclosing_volume() does ref for itself */
+  g_object_unref (operation);
+}
+
+static void
+mount_volume (GtkPlacesView *view,
+              GVolume       *volume)
+{
+  GtkPlacesViewPrivate *priv;
+  GMountOperation *operation;
+  GtkWidget *toplevel;
+
+  priv = gtk_places_view_get_instance_private (view);
+  toplevel = gtk_widget_get_toplevel (GTK_WIDGET (view));
+  operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
+
+  set_busy_cursor (view, TRUE);
+
+  g_cancellable_cancel (priv->cancellable);
+  priv->cancellable = g_cancellable_new ();
+
+  g_mount_operation_set_password_save (operation, G_PASSWORD_SAVE_FOR_SESSION);
+
+  g_volume_mount (volume,
+                  0,
+                  operation,
+                  priv->cancellable,
+                  volume_mount_ready_cb,
+                  view);
+
+  /* unref operation here - g_file_mount_enclosing_volume() does ref for itself */
+  g_object_unref (operation);
+}
+
+/* Callback used when the file list's popup menu is detached */
+static void
+popup_menu_detach_cb (GtkWidget *attach_widget,
+                      GtkMenu   *menu)
+{
+  GtkPlacesViewPrivate *priv;
+
+  priv = gtk_places_view_get_instance_private (GTK_PLACES_VIEW (attach_widget));
+  priv->popup_menu = NULL;
+}
+
+static void
+get_view_and_file (GtkPlacesViewRow  *row,
+                   GtkWidget        **view,
+                   GFile            **file)
+{
+  if (view)
+    *view = gtk_widget_get_ancestor (GTK_WIDGET (row), GTK_TYPE_PLACES_VIEW);
+
+  if (file)
+    {
+      GVolume *volume;
+      GMount *mount;
+
+      volume = gtk_places_view_row_get_volume (row);
+      mount = gtk_places_view_row_get_mount (row);
+
+      if (mount)
+        *file = g_mount_get_root (mount);
+      else if (volume)
+        *file = g_volume_get_activation_root (volume);
+      else
+        *file = NULL;
+    }
+}
+
+static void
+open_cb (GtkMenuItem      *item,
+         GtkPlacesViewRow *row)
+{
+  GtkWidget *view;
+  GFile *file;
+
+  get_view_and_file (row, &view, &file);
+
+  if (file)
+    emit_open_location (GTK_PLACES_VIEW (view), file, GTK_PLACES_OPEN_NORMAL);
+
+  g_clear_object (&file);
+}
+
+static void
+open_in_new_tab_cb (GtkMenuItem      *item,
+                    GtkPlacesViewRow *row)
+{
+  GtkWidget *view;
+  GFile *file;
+
+  get_view_and_file (row, &view, &file);
+
+  if (file)
+    emit_open_location (GTK_PLACES_VIEW (view), file, GTK_PLACES_OPEN_NEW_TAB);
+
+  g_clear_object (&file);
+}
+
+static void
+open_in_new_window_cb (GtkMenuItem      *item,
+                       GtkPlacesViewRow *row)
+{
+  GtkWidget *view;
+  GFile *file;
+
+  get_view_and_file (row, &view, &file);
+
+  if (file)
+    emit_open_location (GTK_PLACES_VIEW (view), file, GTK_PLACES_OPEN_NEW_WINDOW);
+
+  g_clear_object (&file);
+}
+
+static void
+mount_cb (GtkMenuItem      *item,
+          GtkPlacesViewRow *row)
+{
+  GtkPlacesViewPrivate *priv;
+  GtkWidget *view;
+  GVolume *volume;
+
+  view = gtk_widget_get_ancestor (GTK_WIDGET (row), GTK_TYPE_PLACES_VIEW);
+  priv = gtk_places_view_get_instance_private (GTK_PLACES_VIEW (view));
+  volume = gtk_places_view_row_get_volume (row);
+
+  /*
+   * When the mount item is activated, it's expected that
+   * the volume only gets mounted, without opening it after
+   * the operation is complete.
+   */
+  priv->should_open_location = FALSE;
+
+  gtk_places_view_row_set_busy (row, TRUE);
+  mount_volume (GTK_PLACES_VIEW (view), volume);
+}
+
+static void
+unmount_cb (GtkMenuItem      *item,
+            GtkPlacesViewRow *row)
+{
+  GtkWidget *view;
+  GMount *mount;
+
+  view = gtk_widget_get_ancestor (GTK_WIDGET (row), GTK_TYPE_PLACES_VIEW);
+  mount = gtk_places_view_row_get_mount (row);
+
+  gtk_places_view_row_set_busy (row, TRUE);
+
+  unmount_mount (GTK_PLACES_VIEW (view), mount);
+}
+
+/* Constructs the popup menu if needed */
+static void
+build_popup_menu (GtkPlacesView    *view,
+                  GtkPlacesViewRow *row)
+{
+  GtkPlacesViewPrivate *priv;
+  GtkWidget *item;
+  GMount *mount;
+
+  priv = gtk_places_view_get_instance_private (view);
+  mount = gtk_places_view_row_get_mount (row);
+
+  priv->popup_menu = gtk_menu_new ();
+  gtk_style_context_add_class (gtk_widget_get_style_context (priv->popup_menu),
+                               GTK_STYLE_CLASS_CONTEXT_MENU);
+
+  gtk_menu_attach_to_widget (GTK_MENU (priv->popup_menu),
+                             GTK_WIDGET (view),
+                             popup_menu_detach_cb);
+
+  /* Open item is always present */
+  item = gtk_menu_item_new_with_mnemonic (_("_Open"));
+  g_signal_connect (item,
+                    "activate",
+                    G_CALLBACK (open_cb),
+                    row);
+  gtk_widget_show (item);
+  gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), item);
+
+  if (priv->open_flags & GTK_PLACES_OPEN_NEW_TAB)
+    {
+      item = gtk_menu_item_new_with_mnemonic (_("Open in New _Tab"));
+      g_signal_connect (item,
+                        "activate",
+                        G_CALLBACK (open_in_new_tab_cb),
+                        row);
+      gtk_widget_show (item);
+      gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), item);
+    }
+
+  if (priv->open_flags & GTK_PLACES_OPEN_NEW_WINDOW)
+    {
+      item = gtk_menu_item_new_with_mnemonic (_("Open in New _Window"));
+      g_signal_connect (item,
+                        "activate",
+                        G_CALLBACK (open_in_new_window_cb),
+                        row);
+      gtk_widget_show (item);
+      gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), item);
+    }
+
+  /* Separator */
+  item = gtk_separator_menu_item_new ();
+  gtk_widget_show (item);
+  gtk_menu_shell_insert (GTK_MENU_SHELL (priv->popup_menu), item, -1);
+
+  /* Mount/Unmount items */
+  if (mount)
+    {
+      item = gtk_menu_item_new_with_mnemonic (_("_Unmount"));
+      g_signal_connect (item,
+                        "activate",
+                        G_CALLBACK (unmount_cb),
+                        row);
+      gtk_widget_show (item);
+      gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), item);
+    }
+  else
+    {
+      item = gtk_menu_item_new_with_mnemonic (_("_Mount"));
+      g_signal_connect (item,
+                        "activate",
+                        G_CALLBACK (mount_cb),
+                        row);
+      gtk_widget_show (item);
+      gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), item);
+    }
+}
+
+static void
+popup_menu (GtkPlacesViewRow *row,
+            GdkEventButton   *event)
+{
+  GtkPlacesViewPrivate *priv;
+  GtkWidget *view;
+  gint button;
+
+  view = gtk_widget_get_ancestor (GTK_WIDGET (row), GTK_TYPE_PLACES_VIEW);
+  priv = gtk_places_view_get_instance_private (GTK_PLACES_VIEW (view));
+
+  g_clear_pointer (&priv->popup_menu, gtk_widget_destroy);
+
+  build_popup_menu (GTK_PLACES_VIEW (view), row);
+
+  /* The event button needs to be 0 if we're popping up this menu from
+   * a button release, else a 2nd click outside the menu with any button
+   * other than the one that invoked the menu will be ignored (instead
+   * of dismissing the menu). This is a subtle fragility of the GTK menu code.
+   */
+  if (event)
+    {
+      if (event->type == GDK_BUTTON_PRESS)
+        button = 0;
+      else
+        button = event->button;
+    }
+  else
+    {
+      button = 0;
+    }
+
+  gtk_menu_popup (GTK_MENU (priv->popup_menu),
+                  NULL,
+                  NULL,
+                  NULL,
+                  NULL,
+                  button,
+                  event ? event->time : gtk_get_current_event_time ());
+}
+
+static gboolean
+on_row_popup_menu (GtkPlacesViewRow *row)
+{
+  popup_menu (row, NULL);
+  return TRUE;
+}
+
+static gboolean
+on_button_press_event (GtkPlacesViewRow *row,
+                       GdkEventButton   *event)
+{
+  if (row &&
+      gdk_event_triggers_context_menu ((GdkEvent*) event) &&
+      event->type == GDK_BUTTON_PRESS)
+    {
+      popup_menu (row, event);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+on_key_press_event (GtkWidget     *widget,
+                    GdkEventKey   *event,
+                    GtkPlacesView *view)
+{
+  GtkPlacesViewPrivate *priv;
+
+  priv = gtk_places_view_get_instance_private (view);
+
+  if (event)
+    {
+      guint modifiers;
+
+      modifiers = gtk_accelerator_get_default_mod_mask ();
+
+      if (event->keyval == GDK_KEY_Return ||
+          event->keyval == GDK_KEY_KP_Enter ||
+          event->keyval == GDK_KEY_ISO_Enter ||
+          event->keyval == GDK_KEY_space)
+        {
+          GtkWidget *focus_widget;
+          GtkWindow *toplevel;
+
+          priv->current_open_flags = GTK_PLACES_OPEN_NORMAL;
+          toplevel = get_toplevel (GTK_WIDGET (view));
+
+          if (!toplevel)
+            return FALSE;
+
+          focus_widget = gtk_window_get_focus (toplevel);
+
+          if (!GTK_IS_PLACES_VIEW_ROW (focus_widget))
+            return FALSE;
+
+          if ((event->state & modifiers) == GDK_SHIFT_MASK)
+            priv->current_open_flags = GTK_PLACES_OPEN_NEW_TAB;
+          else if ((event->state & modifiers) == GDK_CONTROL_MASK)
+            priv->current_open_flags = GTK_PLACES_OPEN_NEW_WINDOW;
+
+          activate_row (view, GTK_PLACES_VIEW_ROW (focus_widget), priv->current_open_flags);
+
+          return TRUE;
+        }
+    }
+
+  return FALSE;
+}
+
+static void
+on_eject_button_clicked (GtkWidget        *widget,
+                         GtkPlacesViewRow *row)
+{
+  if (row)
+    {
+      GtkWidget *view = gtk_widget_get_ancestor (GTK_WIDGET (row), GTK_TYPE_PLACES_VIEW);
+
+      unmount_mount (GTK_PLACES_VIEW (view), gtk_places_view_row_get_mount (row));
+    }
+}
+
+static void
+on_connect_button_clicked (GtkPlacesView *view)
+{
+  GtkPlacesViewPrivate *priv;
+  const gchar *uri;
+  GFile *file;
+
+  priv = gtk_places_view_get_instance_private (view);
+  file = NULL;
+
+  /*
+   * Since the 'Connect' button is updated whenever the typed
+   * address changes, it is sufficient to check if it's sensitive
+   * or not, in order to determine if the given address is valid.
+   */
+  if (!gtk_widget_get_sensitive (priv->connect_button))
+    return;
+
+  uri = gtk_entry_get_text (GTK_ENTRY (priv->address_entry));
+
+  if (uri != NULL && uri[0] != '\0')
+    file = g_file_new_for_commandline_arg (uri);
+
+  if (file)
+    {
+      priv->should_open_location = TRUE;
+
+      mount_server (view, file);
+    }
+  else
+    {
+      emit_show_error_message (view, _("Unable to get remote server location"), NULL);
+    }
+}
+
+static void
+on_address_entry_text_changed (GtkPlacesView *view)
+{
+  GtkPlacesViewPrivate *priv;
+  const gchar* const *supported_protocols;
+  gchar *address, *scheme;
+  gboolean supported;
+
+  priv = gtk_places_view_get_instance_private (view);
+  supported = FALSE;
+  supported_protocols = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
+
+  if (!supported_protocols)
+    return;
+
+  address = g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->address_entry)));
+  scheme = g_uri_parse_scheme (address);
+
+  if (!scheme)
+    goto out;
+
+  supported = g_strv_contains (supported_protocols, scheme) &&
+              !g_strv_contains (unsupported_protocols, scheme);
+
+out:
+  gtk_widget_set_sensitive (priv->connect_button, supported);
+  g_free (address);
+}
+
+static void
+on_recent_servers_listbox_row_activated (GtkPlacesView    *view,
+                                         GtkPlacesViewRow *row,
+                                         GtkWidget        *listbox)
+{
+  GtkPlacesViewPrivate *priv;
+  gchar *uri;
+
+  priv = gtk_places_view_get_instance_private (view);
+  uri = g_object_get_data (G_OBJECT (row), "uri");
+
+  gtk_entry_set_text (GTK_ENTRY (priv->address_entry), uri);
+
+  gtk_widget_hide (priv->recent_servers_popover);
+}
+
+static void
+on_listbox_row_activated (GtkPlacesView    *view,
+                          GtkPlacesViewRow *row,
+                          GtkWidget        *listbox)
+{
+  GtkPlacesViewPrivate *priv;
+
+  priv = gtk_places_view_get_instance_private (view);
+
+  activate_row (view, row, priv->current_open_flags);
+}
+
+static gboolean
+listbox_filter_func (GtkListBoxRow *row,
+                     gpointer       user_data)
+{
+  GtkPlacesViewPrivate *priv;
+  gboolean retval;
+  gchar *name;
+  gchar *path;
+
+  priv = gtk_places_view_get_instance_private (GTK_PLACES_VIEW (user_data));
+  retval = FALSE;
+
+  if (!priv->search_query || priv->search_query[0] == '\0')
+    return TRUE;
+
+  g_object_get (row,
+                "name", &name,
+                "path", &path,
+                NULL);
+
+  if (name)
+    retval |= g_strstr_len (name, -1, priv->search_query) != NULL;
+
+  if (path)
+    retval |= g_strstr_len (path, -1, priv->search_query) != NULL;
+
+  g_free (name);
+  g_free (path);
+
+  return retval;
+}
+
+static void
+gtk_places_view_constructed (GObject *object)
+{
+  GtkPlacesViewPrivate *priv;
+
+  priv = gtk_places_view_get_instance_private (GTK_PLACES_VIEW (object));
+
+  G_OBJECT_CLASS (gtk_places_view_parent_class)->constructed (object);
+
+  gtk_list_box_set_filter_func (GTK_LIST_BOX (priv->drives_listbox),
+                                listbox_filter_func,
+                                object,
+                                NULL);
+  gtk_list_box_set_filter_func (GTK_LIST_BOX (priv->network_listbox),
+                                listbox_filter_func,
+                                object,
+                                NULL);
+
+  /* load drives */
+  update_places (GTK_PLACES_VIEW (object));
+
+  g_signal_connect_swapped (priv->volume_monitor,
+                            "mount-added",
+                            G_CALLBACK (update_places),
+                            object);
+  g_signal_connect_swapped (priv->volume_monitor,
+                            "mount-changed",
+                            G_CALLBACK (update_places),
+                            object);
+  g_signal_connect_swapped (priv->volume_monitor,
+                            "mount-removed",
+                            G_CALLBACK (update_places),
+                            object);
+  g_signal_connect_swapped (priv->volume_monitor,
+                            "volume-added",
+                            G_CALLBACK (update_places),
+                            object);
+  g_signal_connect_swapped (priv->volume_monitor,
+                            "volume-changed",
+                            G_CALLBACK (update_places),
+                            object);
+  g_signal_connect_swapped (priv->volume_monitor,
+                            "volume-removed",
+                            G_CALLBACK (update_places),
+                            object);
+}
+
+static void
+gtk_places_view_map (GtkWidget *widget)
+{
+  GtkPlacesViewPrivate *priv;
+
+  priv = gtk_places_view_get_instance_private (GTK_PLACES_VIEW (widget));
+
+  gtk_entry_set_text (GTK_ENTRY (priv->address_entry), "");
+
+  GTK_WIDGET_CLASS (gtk_places_view_parent_class)->map (widget);
+}
+
+static void
+gtk_places_view_class_init (GtkPlacesViewClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->finalize = gtk_places_view_finalize;
+  object_class->constructed = gtk_places_view_constructed;
+  object_class->get_property = gtk_places_view_get_property;
+  object_class->set_property = gtk_places_view_set_property;
+
+  widget_class->map = gtk_places_view_map;
+
+  /**
+   * GtkPlacesView::open-location:
+   * @view: the object which received the signal.
+   * @location: (type Gio.File): #GFile to which the caller should switch.
+   *
+   * The places view emits this signal when the user selects a location
+   * in it.  The calling application should display the contents of that
+   * location; for example, a file manager should show a list of files in
+   * the specified location.
+   *
+   * Since: 3.18
+   */
+  places_view_signals [OPEN_LOCATION] =
+          g_signal_new (I_("open-location"),
+                        G_OBJECT_CLASS_TYPE (object_class),
+                        G_SIGNAL_RUN_FIRST,
+                        G_STRUCT_OFFSET (GtkPlacesViewClass, open_location),
+                        NULL, NULL, NULL,
+                        G_TYPE_NONE, 2,
+                        G_TYPE_OBJECT,
+                        GTK_TYPE_PLACES_OPEN_FLAGS);
+
+  /**
+   * GtkPlacesView::show-error-message:
+   * @view: the object which received the signal.
+   * @primary: primary message with a summary of the error to show.
+   * @secondary: secondary message with details of the error to show.
+   *
+   * The places view emits this signal when it needs the calling
+   * application to present an error message.  Most of these messages
+   * refer to mounting or unmounting media, for example, when a drive
+   * cannot be started for some reason.
+   *
+   * Since: 3.18
+   */
+  places_view_signals [SHOW_ERROR_MESSAGE] =
+          g_signal_new (I_("show-error-message"),
+                        G_OBJECT_CLASS_TYPE (object_class),
+                        G_SIGNAL_RUN_FIRST,
+                        G_STRUCT_OFFSET (GtkPlacesViewClass, show_error_message),
+                        NULL, NULL,
+                        _gtk_marshal_VOID__STRING_STRING,
+                        G_TYPE_NONE, 2,
+                        G_TYPE_STRING,
+                        G_TYPE_STRING);
+
+  properties[PROP_LOCAL_ONLY] =
+          g_param_spec_boolean ("local-only",
+                                P_("Local Only"),
+                                P_("Whether the sidebar only includes local files"),
+                                FALSE,
+                                G_PARAM_READWRITE);
+
+  properties[PROP_OPEN_FLAGS] =
+          g_param_spec_flags ("open-flags",
+                              P_("Open Flags"),
+                              P_("Modes in which the calling application can open locations selected in the 
sidebar"),
+                              GTK_TYPE_PLACES_OPEN_FLAGS,
+                              GTK_PLACES_OPEN_NORMAL,
+                              G_PARAM_READWRITE);
+
+  g_object_class_install_properties (object_class, LAST_PROP, properties);
+
+  /* Bind class to template */
+  gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/ui/gtkplacesview.ui");
+
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, actionbar);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, address_entry);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, address_entry_completion);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, completion_store);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, connect_button);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, drives_box);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, drives_listbox);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, network_grid);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, network_listbox);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, recent_servers_listbox);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, recent_servers_popover);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, recent_servers_stack);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkPlacesView, stack);
+
+  gtk_widget_class_bind_template_callback (widget_class, on_address_entry_text_changed);
+  gtk_widget_class_bind_template_callback (widget_class, on_connect_button_clicked);
+  gtk_widget_class_bind_template_callback (widget_class, on_key_press_event);
+  gtk_widget_class_bind_template_callback (widget_class, on_listbox_row_activated);
+  gtk_widget_class_bind_template_callback (widget_class, on_recent_servers_listbox_row_activated);
+}
+
+static void
+gtk_places_view_init (GtkPlacesView *self)
+{
+  GtkPlacesViewPrivate *priv;
+
+  priv = gtk_places_view_get_instance_private (self);
+
+  priv->volume_monitor = g_volume_monitor_get ();
+  priv->open_flags = GTK_PLACES_OPEN_NORMAL;
+
+  gtk_widget_init_template (GTK_WIDGET (self));
+}
+
+/**
+ * gtk_places_view_new:
+ *
+ * Creates a new #GtkPlacesView widget.
+ *
+ * The application should connect to at least the
+ * #GtkPlacesView::open-location signal to be notified
+ * when the user makes a selection in the view.
+ *
+ * Returns: a newly created #GtkPlacesView
+ *
+ * Since: 3.18
+ */
+GtkWidget *
+gtk_places_view_new (void)
+{
+  return g_object_new (GTK_TYPE_PLACES_VIEW, NULL);
+}
+
+/**
+ * gtk_places_view_set_open_flags:
+ * @view: a #GtkPlacesView
+ * @flags: Bitmask of modes in which the calling application can open locations
+ *
+ * Sets the way in which the calling application can open new locations from
+ * the places view.  For example, some applications only open locations
+ * “directly” into their main view, while others may support opening locations
+ * in a new notebook tab or a new window.
+ *
+ * This function is used to tell the places @view about the ways in which the
+ * application can open new locations, so that the view can display (or not)
+ * the “Open in new tab” and “Open in new window” menu items as appropriate.
+ *
+ * When the #GtkPlacesView::open-location signal is emitted, its flags
+ * argument will be set to one of the @flags that was passed in
+ * gtk_places_view_set_open_flags().
+ *
+ * Passing 0 for @flags will cause #GTK_PLACES_OPEN_NORMAL to always be sent
+ * to callbacks for the “open-location” signal.
+ *
+ * Since: 3.18
+ */
+void
+gtk_places_view_set_open_flags (GtkPlacesView      *view,
+                                GtkPlacesOpenFlags  flags)
+{
+  GtkPlacesViewPrivate *priv;
+
+  g_return_if_fail (GTK_IS_PLACES_VIEW (view));
+
+  priv = gtk_places_view_get_instance_private (view);
+
+  if (priv->open_flags != flags)
+    {
+      priv->open_flags = flags;
+      g_object_notify_by_pspec (G_OBJECT (view), properties[PROP_OPEN_FLAGS]);
+    }
+}
+
+/**
+ * gtk_places_view_get_open_flags:
+ * @view: a #GtkPlacesSidebar
+ *
+ * Gets the open flags.
+ *
+ * Returns: the #GtkPlacesOpenFlags of @view
+ *
+ * Since: 3.18
+ */
+GtkPlacesOpenFlags
+gtk_places_view_get_open_flags (GtkPlacesView *view)
+{
+  GtkPlacesViewPrivate *priv;
+
+  g_return_val_if_fail (GTK_IS_PLACES_VIEW (view), 0);
+
+  priv = gtk_places_view_get_instance_private (view);
+
+  return priv->open_flags;
+}
+
+/**
+ * gtk_places_view_get_search_query:
+ * @view: a #GtkPlacesView
+ *
+ * Retrieves the current search query from @view.
+ *
+ * Returns: (transfer none): the current search query.
+ */
+const gchar*
+gtk_places_view_get_search_query (GtkPlacesView *view)
+{
+  GtkPlacesViewPrivate *priv;
+
+  g_return_val_if_fail (GTK_IS_PLACES_VIEW (view), NULL);
+
+  priv = gtk_places_view_get_instance_private (view);
+
+  return priv->search_query;
+}
+
+/**
+ * gtk_places_view_get_search_query:
+ * @view: a #GtkPlacesView
+ * @query_text: the query, or NULL.
+ *
+ * Sets the search query of @view. The search is immediately performed
+ * once the query is set.
+ *
+ * Returns:
+ */
+void
+gtk_places_view_set_search_query (GtkPlacesView *view,
+                                  const gchar   *query_text)
+{
+  GtkPlacesViewPrivate *priv;
+
+  g_return_if_fail (GTK_IS_PLACES_VIEW (view));
+
+  priv = gtk_places_view_get_instance_private (view);
+
+  if (g_strcmp0 (priv->search_query, query_text) != 0)
+    {
+      g_clear_pointer (&priv->search_query, g_free);
+      priv->search_query = g_strdup (query_text);
+
+      gtk_list_box_invalidate_filter (GTK_LIST_BOX (priv->drives_listbox));
+      gtk_list_box_invalidate_filter (GTK_LIST_BOX (priv->network_listbox));
+
+      update_search_widgets (view);
+    }
+}
+
+/**
+ * gtk_places_view_get_local_only:
+ * @view: a #GtkPlacesView
+ *
+ * Returns %TRUE if only local volumes are shown, i.e. no networks
+ * are displayed.
+ *
+ * Returns: %TRUE if only local volumes are shown, %FALSE otherwise.
+ *
+ * Since: 3.18
+ */
+gboolean
+gtk_places_view_get_local_only (GtkPlacesView *view)
+{
+  GtkPlacesViewPrivate *priv;
+
+  g_return_val_if_fail (GTK_IS_PLACES_VIEW (view), FALSE);
+
+  priv = gtk_places_view_get_instance_private (view);
+
+  return priv->local_only;
+}
+
+/**
+ * gtk_places_view_set_local_only:
+ * @view: a #GtkPlacesView
+ * @local_only: %TRUE to hide remote locations, %FALSE to show.
+ *
+ * Sets the #GtkPlacesView::local-only property to @local_only.
+ *
+ * Returns:
+ *
+ * Since: 3.18
+ */
+void
+gtk_places_view_set_local_only (GtkPlacesView *view,
+                                gboolean       local_only)
+{
+  GtkPlacesViewPrivate *priv;
+
+  g_return_if_fail (GTK_IS_PLACES_VIEW (view));
+
+  priv = gtk_places_view_get_instance_private (view);
+
+  if (priv->local_only != local_only)
+    {
+      priv->local_only = local_only;
+
+      gtk_widget_set_visible (priv->actionbar, !local_only);
+      gtk_widget_set_visible (priv->network_grid, !local_only);
+
+      g_object_notify_by_pspec (G_OBJECT (view), properties [PROP_LOCAL_ONLY]);
+    }
+}
diff --git a/gtk/gtkplacesviewprivate.h b/gtk/gtkplacesviewprivate.h
new file mode 100644
index 0000000..17f55fd
--- /dev/null
+++ b/gtk/gtkplacesviewprivate.h
@@ -0,0 +1,93 @@
+/* gtkplacesview.h
+ *
+ * Copyright (C) 2015 Georges Basile Stavracas Neto <georges stavracas gmail com>
+ *
+ * This program 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef GTK_PLACES_VIEW_H
+#define GTK_PLACES_VIEW_H
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gtk/gtkbox.h>
+#include <gtk/gtkplacessidebar.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_PLACES_VIEW        (gtk_places_view_get_type ())
+#define GTK_PLACES_VIEW(obj)        (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PLACES_VIEW, GtkPlacesView))
+#define GTK_PLACES_VIEW_CLASS(klass)(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PLACES_VIEW, 
GtkPlacesViewClass))
+#define GTK_IS_PLACES_VIEW(obj)     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PLACES_VIEW))
+#define GTK_IS_PLACES_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PLACES_VIEW))
+#define GTK_PLACES_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PLACES_VIEW, 
GtkPlacesViewClass))
+
+typedef struct _GtkPlacesView GtkPlacesView;
+typedef struct _GtkPlacesViewClass GtkPlacesViewClass;
+typedef struct _GtkPlacesViewPrivate GtkPlacesViewPrivate;
+
+struct _GtkPlacesViewClass
+{
+  GtkBoxClass parent_class;
+
+  void     (* open_location)        (GtkPlacesView          *view,
+                                     GFile                  *location,
+                                     GtkPlacesOpenFlags  open_flags);
+
+  void    (* show_error_message)     (GtkPlacesSidebar      *sidebar,
+                                      const gchar           *primary,
+                                      const gchar           *secondary);
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  gpointer reserved[10];
+};
+
+struct _GtkPlacesView
+{
+  GtkBox parent_instance;
+};
+
+GDK_AVAILABLE_IN_3_18
+GType              gtk_places_view_get_type                      (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_3_18
+GtkPlacesOpenFlags gtk_places_view_get_open_flags                (GtkPlacesView      *view);
+GDK_AVAILABLE_IN_3_18
+void               gtk_places_view_set_open_flags                (GtkPlacesView      *view,
+                                                                  GtkPlacesOpenFlags  flags);
+
+GDK_AVAILABLE_IN_3_18
+const gchar*       gtk_places_view_get_search_query              (GtkPlacesView      *view);
+GDK_AVAILABLE_IN_3_18
+void               gtk_places_view_set_search_query              (GtkPlacesView      *view,
+                                                                  const gchar        *query_text);
+
+GDK_AVAILABLE_IN_3_18
+gboolean           gtk_places_view_get_local_only                (GtkPlacesView         *view);
+
+GDK_AVAILABLE_IN_3_18
+void               gtk_places_view_set_local_only                (GtkPlacesView         *view,
+                                                                  gboolean               local_only);
+
+GDK_AVAILABLE_IN_3_18
+GtkWidget *        gtk_places_view_new                           (void);
+
+G_END_DECLS
+
+#endif /* GTK_PLACES_VIEW_H */
diff --git a/gtk/gtkplacesviewrow.c b/gtk/gtkplacesviewrow.c
new file mode 100644
index 0000000..44c8644
--- /dev/null
+++ b/gtk/gtkplacesviewrow.c
@@ -0,0 +1,246 @@
+/* gtkplacesviewrow.c
+ *
+ * Copyright (C) 2015 Georges Basile Stavracas Neto <georges stavracas gmail com>
+ *
+ * This program 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gio/gio.h>
+#include <gtk/gtk.h>
+
+#include "gtkintl.h"
+#include "gtkplacesviewrowprivate.h"
+#include "gtktypebuiltins.h"
+
+struct _GtkPlacesViewRow
+{
+  GtkListBoxRow  parent_instance;
+
+  GtkSpinner    *busy_spinner;
+  GtkButton     *eject_button;
+  GtkEventBox   *event_box;
+  GtkImage      *icon_image;
+  GtkLabel      *name_label;
+  GtkLabel      *path_label;
+
+  GVolume       *volume;
+  GMount        *mount;
+};
+
+G_DEFINE_TYPE (GtkPlacesViewRow, gtk_places_view_row, GTK_TYPE_LIST_BOX_ROW)
+
+enum {
+  PROP_0,
+  PROP_ICON,
+  PROP_NAME,
+  PROP_PATH,
+  PROP_VOLUME,
+  PROP_MOUNT,
+  LAST_PROP
+};
+
+static GParamSpec *properties [LAST_PROP];
+
+static void
+gtk_places_view_row_get_property (GObject    *object,
+                                  guint       prop_id,
+                                  GValue     *value,
+                                  GParamSpec *pspec)
+{
+  GtkPlacesViewRow *self;
+  GIcon *icon;
+
+  self = GTK_PLACES_VIEW_ROW (object);
+  icon = NULL;
+
+  switch (prop_id)
+    {
+    case PROP_ICON:
+      gtk_image_get_gicon (self->icon_image, &icon, NULL);
+      g_value_set_object (value, icon);
+      break;
+
+    case PROP_NAME:
+      g_value_set_string (value, gtk_label_get_label (self->name_label));
+      break;
+
+    case PROP_PATH:
+      g_value_set_string (value, gtk_label_get_label (self->path_label));
+      break;
+
+    case PROP_VOLUME:
+      g_value_set_object (value, self->volume);
+      break;
+
+    case PROP_MOUNT:
+      g_value_set_object (value, self->mount);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtk_places_view_row_set_property (GObject      *object,
+                                  guint         prop_id,
+                                  const GValue *value,
+                                  GParamSpec   *pspec)
+{
+  GtkPlacesViewRow *self = GTK_PLACES_VIEW_ROW (object);
+
+  switch (prop_id)
+    {
+    case PROP_ICON:
+      gtk_image_set_from_gicon (self->icon_image,
+                                g_value_get_object (value),
+                                GTK_ICON_SIZE_LARGE_TOOLBAR);
+      break;
+
+    case PROP_NAME:
+      gtk_label_set_label (self->name_label, g_value_get_string (value));
+      break;
+
+    case PROP_PATH:
+      gtk_label_set_label (self->path_label, g_value_get_string (value));
+      break;
+
+    case PROP_VOLUME:
+      self->volume = g_value_get_object (value);
+      break;
+
+    case PROP_MOUNT:
+      self->mount = g_value_get_object (value);
+      gtk_widget_set_visible (GTK_WIDGET (self->eject_button), self->mount != NULL);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtk_places_view_row_class_init (GtkPlacesViewRowClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->get_property = gtk_places_view_row_get_property;
+  object_class->set_property = gtk_places_view_row_set_property;
+
+  properties[PROP_ICON] =
+          g_param_spec_object ("icon",
+                               P_("Icon of the row"),
+                               P_("The icon representing the volume"),
+                               G_TYPE_ICON,
+                               G_PARAM_READWRITE);
+
+  properties[PROP_NAME] =
+          g_param_spec_string ("name",
+                               P_("Name of the volume"),
+                               P_("The name of the volume"),
+                               "",
+                               G_PARAM_READWRITE);
+
+  properties[PROP_PATH] =
+          g_param_spec_string ("path",
+                               P_("Path of the volume"),
+                               P_("The path of the volume"),
+                               "",
+                               G_PARAM_READWRITE);
+
+  properties[PROP_VOLUME] =
+          g_param_spec_object ("volume",
+                               P_("Volume represented by the row"),
+                               P_("The volume represented by the row"),
+                               G_TYPE_VOLUME,
+                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+  properties[PROP_MOUNT] =
+          g_param_spec_object ("mount",
+                               P_("Mount represented by the row"),
+                               P_("The mount point represented by the row, if any"),
+                               G_TYPE_MOUNT,
+                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+  g_object_class_install_properties (object_class, LAST_PROP, properties);
+
+  gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/ui/gtkplacesviewrow.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, GtkPlacesViewRow, busy_spinner);
+  gtk_widget_class_bind_template_child (widget_class, GtkPlacesViewRow, eject_button);
+  gtk_widget_class_bind_template_child (widget_class, GtkPlacesViewRow, event_box);
+  gtk_widget_class_bind_template_child (widget_class, GtkPlacesViewRow, icon_image);
+  gtk_widget_class_bind_template_child (widget_class, GtkPlacesViewRow, name_label);
+  gtk_widget_class_bind_template_child (widget_class, GtkPlacesViewRow, path_label);
+}
+
+static void
+gtk_places_view_row_init (GtkPlacesViewRow *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+}
+
+GtkWidget*
+gtk_places_view_row_new (GVolume *volume,
+                         GMount  *mount)
+{
+  return g_object_new (GTK_TYPE_PLACES_VIEW_ROW,
+                       "volume", volume,
+                       "mount", mount,
+                       NULL);
+}
+
+GMount*
+gtk_places_view_row_get_mount (GtkPlacesViewRow *row)
+{
+  g_return_val_if_fail (GTK_IS_PLACES_VIEW_ROW (row), NULL);
+
+  return row->mount;
+}
+
+GVolume*
+gtk_places_view_row_get_volume (GtkPlacesViewRow *row)
+{
+  g_return_val_if_fail (GTK_IS_PLACES_VIEW_ROW (row), NULL);
+
+  return row->volume;
+}
+
+GtkWidget*
+gtk_places_view_row_get_eject_button (GtkPlacesViewRow *row)
+{
+  g_return_val_if_fail (GTK_IS_PLACES_VIEW_ROW (row), NULL);
+
+  return GTK_WIDGET (row->eject_button);
+}
+
+GtkWidget*
+gtk_places_view_row_get_event_box (GtkPlacesViewRow *row)
+{
+  g_return_val_if_fail (GTK_IS_PLACES_VIEW_ROW (row), NULL);
+
+  return GTK_WIDGET (row->event_box);
+}
+
+void
+gtk_places_view_row_set_busy (GtkPlacesViewRow *row,
+                              gboolean          is_busy)
+{
+  g_return_if_fail (GTK_IS_PLACES_VIEW_ROW (row));
+
+  gtk_widget_set_visible (GTK_WIDGET (row->busy_spinner), is_busy);
+}
diff --git a/gtk/gtkplacesviewrowprivate.h b/gtk/gtkplacesviewrowprivate.h
new file mode 100644
index 0000000..150140b
--- /dev/null
+++ b/gtk/gtkplacesviewrowprivate.h
@@ -0,0 +1,51 @@
+/* gtkplacesviewrow.h
+ *
+ * Copyright (C) 2015 Georges Basile Stavracas Neto <georges stavracas gmail com>
+ *
+ * This program 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GTK_PLACES_VIEW_ROW_H
+#define GTK_PLACES_VIEW_ROW_H
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include "gtkwidget.h"
+#include "gtklistbox.h"
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_PLACES_VIEW_ROW (gtk_places_view_row_get_type())
+
+G_DECLARE_FINAL_TYPE (GtkPlacesViewRow, gtk_places_view_row, GTK, PLACES_VIEW_ROW, GtkListBoxRow)
+
+GtkWidget*         gtk_places_view_row_new                       (GVolume            *volume,
+                                                                  GMount             *mount);
+
+GtkWidget*         gtk_places_view_row_get_eject_button          (GtkPlacesViewRow   *row);
+
+GtkWidget*         gtk_places_view_row_get_event_box             (GtkPlacesViewRow   *row);
+
+GMount*            gtk_places_view_row_get_mount                 (GtkPlacesViewRow   *row);
+
+GVolume*           gtk_places_view_row_get_volume                (GtkPlacesViewRow   *row);
+
+void               gtk_places_view_row_set_busy                  (GtkPlacesViewRow   *row,
+                                                                  gboolean            is_busy);
+
+G_END_DECLS
+
+#endif /* GTK_PLACES_VIEW_ROW_H */
diff --git a/gtk/ui/gtkplacesview.ui b/gtk/ui/gtkplacesview.ui
new file mode 100644
index 0000000..1170aeb
--- /dev/null
+++ b/gtk/ui/gtkplacesview.ui
@@ -0,0 +1,503 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <requires lib="gtk+" version="3.16"/>
+    <object class="GtkListStore" id="completion_store">
+    <columns>
+      <!-- column-name name -->
+      <column type="gchararray"/>
+      <!-- column-name uri -->
+      <column type="gchararray"/>
+    </columns>
+  </object>
+  <object class="GtkEntryCompletion" id="address_entry_completion">
+    <property name="model">completion_store</property>
+    <property name="minimum_key_length">1</property>
+    <property name="text_column">1</property>
+    <property name="inline_completion">True</property>
+    <property name="popup_completion">False</property>
+  </object>
+  <object class="GtkPopover" id="recent_servers_popover">
+    <child>
+      <object class="GtkStack" id="recent_servers_stack">
+        <property name="visible">True</property>
+        <child>
+          <object class="GtkBox" id="empty_servers_box">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="vexpand">True</property>
+            <property name="valign">center</property>
+            <property name="orientation">vertical</property>
+            <property name="spacing">18</property>
+            <child>
+              <object class="GtkImage" id="empty_servers_image">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="pixel-size">48</property>
+                <property name="icon_name">network-server-symbolic</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel" id="empty_servers_label">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="label" translatable="yes">No recent servers found</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="name">empty</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox" id="box">
+            <property name="visible">True</property>
+            <property name="border_width">12</property>
+            <property name="orientation">vertical</property>
+            <property name="spacing">12</property>
+            <child>
+              <object class="GtkLabel" id="recent_servers_title_label">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="label" translatable="yes">Recent Servers</property>
+                <attributes>
+                  <attribute name="weight" value="bold"/>
+                </attributes>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkScrolledWindow" id="recent_servers_list_scroll">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="vexpand">True</property>
+                <property name="shadow_type">in</property>
+                <property name="min_content_width">250</property>
+                <property name="min_content_height">150</property>
+                <child>
+                  <object class="GtkViewport" id="recent_servers_list_viewport">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="shadow_type">none</property>
+                    <child>
+                      <object class="GtkListBox" id="recent_servers_listbox">
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <property name="selection_mode">none</property>
+                        <signal name="row-activated" handler="on_recent_servers_listbox_row_activated" 
object="GtkPlacesView" swapped="yes" />
+                      </object>
+                    </child>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="name">list</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </object>
+  <template class="GtkPlacesView" parent="GtkBox">
+    <property name="visible">True</property>
+    <property name="can_focus">False</property>
+    <property name="orientation">vertical</property>
+    <signal name="key-press-event" handler="on_key_press_event" object="GtkPlacesView" swapped="no" />
+    <child>
+      <object class="GtkStack" id="stack">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="vhomogeneous">False</property>
+        <property name="transition_type">crossfade</property>
+        <child>
+          <object class="GtkFrame" id="frame">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="label_xalign">0</property>
+            <property name="shadow_type">none</property>
+            <child>
+              <object class="GtkScrolledWindow" id="scrolled_window">
+                <property name="visible">True</property>
+                <property name="hexpand">True</property>
+                <property name="vexpand">True</property>
+                <child>
+                  <object class="GtkViewport" id="viewport">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="shadow_type">none</property>
+                    <child>
+                      <object class="GtkBox" id="main_box">
+                        <property name="visible">True</property>
+                        <property name="hexpand">True</property>
+                        <property name="can_focus">False</property>
+                        <property name="orientation">vertical</property>
+                        <child>
+                          <object class="GtkBox" id="drives_box">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="orientation">vertical</property>
+                            <child>
+                              <object class="GtkLabel" id="drives_title_label">
+                                <property name="visible">True</property>
+                                <property name="margin_start">12</property>
+                                <property name="margin_end">12</property>
+                                <property name="margin_top">6</property>
+                                <property name="margin_bottom">6</property>
+                                <property name="label" translatable="yes">This Computer</property>
+                                <property name="xalign">0</property>
+                                <attributes>
+                                  <attribute name="weight" value="bold"/>
+                                </attributes>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkSeparator" id="separator1">
+                                <property name="visible">True</property>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkListBox" id="drives_listbox">
+                                <property name="visible">True</property>
+                                <property name="can_focus">True</property>
+                                <property name="selection_mode">none</property>
+                                <signal name="row-activated" handler="on_listbox_row_activated" 
object="GtkPlacesView" swapped="yes" />
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">2</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkGrid" id="network_grid">
+                            <property name="visible">True</property>
+                            <property name="hexpand">True</property>
+                            <property name="can_focus">False</property>
+                            <child>
+                              <object class="GtkLabel" id="network_title_label">
+                                <property name="visible">True</property>
+                                <property name="margin_start">12</property>
+                                <property name="margin_end">12</property>
+                                <property name="margin_top">6</property>
+                                <property name="margin_bottom">6</property>
+                                <property name="hexpand">False</property>
+                                <property name="label" translatable="yes">Network</property>
+                                <property name="ellipsize">end</property>
+                                <property name="xalign">0</property>
+                                <attributes>
+                                  <attribute name="weight" value="bold"/>
+                                </attributes>
+                              </object>
+                              <packing>
+                                <property name="left_attach">0</property>
+                                <property name="top_attach">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkSpinner" id="network_spinner">
+                                <property name="visible">True</property>
+                                <property name="halign">start</property>
+                                <property name="hexpand">True</property>
+                                <property name="can_focus">False</property>
+                              </object>
+                              <packing>
+                                <property name="left_attach">1</property>
+                                <property name="top_attach">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkSeparator" id="separator2">
+                                <property name="visible">True</property>
+                                <property name="hexpand">True</property>
+                                <property name="can_focus">False</property>
+                              </object>
+                              <packing>
+                                <property name="left_attach">0</property>
+                                <property name="top_attach">1</property>
+                                <property name="width">2</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkListBox" id="network_listbox">
+                                <property name="visible">True</property>
+                                <property name="can_focus">True</property>
+                                <property name="selection_mode">none</property>
+                                <signal name="row-activated" handler="on_listbox_row_activated" 
object="GtkPlacesView" swapped="yes" />
+                              </object>
+                              <packing>
+                                <property name="left_attach">0</property>
+                                <property name="top_attach">2</property>
+                                <property name="width">2</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                    </child>
+                    <style>
+                      <class name="view"/>
+                    </style>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+          <packing>
+            <property name="name">lists</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="halign">center</property>
+            <property name="valign">center</property>
+            <property name="hexpand">True</property>
+            <property name="vexpand">True</property>
+            <property name="orientation">vertical</property>
+            <property name="spacing">12</property>
+            <child>
+              <object class="GtkImage">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="pixel_size">72</property>
+                <property name="icon_name">drive-harddisk-symbolic</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="label" translatable="yes">No drives or networks found</property>
+                <attributes>
+                  <attribute name="weight" value="bold"/>
+                  <attribute name="scale" value="1.44"/>
+                </attributes>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="name">empty</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="halign">center</property>
+            <property name="valign">center</property>
+            <property name="hexpand">True</property>
+            <property name="vexpand">True</property>
+            <property name="orientation">vertical</property>
+            <property name="spacing">12</property>
+            <child>
+              <object class="GtkImage">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="pixel_size">72</property>
+                <property name="icon_name">edit-find-symbolic</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="label" translatable="yes">No results found</property>
+                <attributes>
+                  <attribute name="weight" value="bold"/>
+                  <attribute name="scale" value="1.44"/>
+                </attributes>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="label" translatable="yes">Try a different search</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="name">search</property>
+            <property name="position">2</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="fill">True</property>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkActionBar" id="actionbar">
+        <property name="visible">True</property>
+        <property name="hexpand">True</property>
+        <property name="can_focus">False</property>
+        <child>
+          <object class="GtkLabel" id="connect_to_server_label">
+            <property name="visible">True</property>
+            <property name="hexpand">True</property>
+            <property name="can_focus">False</property>
+            <property name="xalign">0</property>
+            <property name="label" translatable="yes">Connect to _Server</property>
+            <property name="use_underline">True</property>
+            <attributes>
+              <attribute name="weight" value="bold"/>
+            </attributes>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="connect_button">
+            <property name="label" translatable="yes">Con_nect</property>
+            <property name="use_underline">True</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="sensitive">False</property>
+            <property name="receives_default">True</property>
+            <signal name="clicked" handler="on_connect_button_clicked" object="GtkPlacesView" swapped="yes" 
/>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox" id="address_box">
+            <property name="visible">True</property>
+            <property name="hexpand">True</property>
+            <property name="can_focus">False</property>
+            <child>
+              <object class="GtkEntry" id="address_entry">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="hexpand">True</property>
+                <property name="width_chars">20</property>
+                <property name="placeholder_text" translatable="yes">Address…</property>
+                <property name="completion">address_entry_completion</property>
+                <signal name="notify::text" handler="on_address_entry_text_changed" object="GtkPlacesView" 
swapped="yes" />
+                <signal name="activate" handler="on_connect_button_clicked" object="GtkPlacesView" 
swapped="yes" />
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkMenuButton" id="server_list_button">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="direction">up</property>
+                <property name="popover">recent_servers_popover</property>
+                <child>
+                  <object class="GtkImage" id="arrow_up_image">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="icon_name">pan-up-symbolic</property>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+              </packing>
+            </child>
+            <style>
+              <class name="linked"/>
+            </style>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="fill">True</property>
+        <property name="position">1</property>
+      </packing>
+    </child>
+  </template>
+</interface>
diff --git a/gtk/ui/gtkplacesviewrow.ui b/gtk/ui/gtkplacesviewrow.ui
new file mode 100644
index 0000000..926cb4c
--- /dev/null
+++ b/gtk/ui/gtkplacesviewrow.ui
@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <requires lib="gtk+" version="3.16"/>
+  <template class="GtkPlacesViewRow" parent="GtkListBoxRow">
+    <property name="width_request">100</property>
+    <property name="visible">True</property>
+    <property name="can_focus">True</property>
+    <style>
+      <class name="volume-row" />
+    </style>
+    <child>
+      <object class="GtkEventBox" id="event_box">
+        <property name="visible">True</property>
+        <child>
+          <object class="GtkBox" id="box">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="margin_start">12</property>
+            <property name="margin_end">12</property>
+            <property name="margin_top">6</property>
+            <property name="margin_bottom">6</property>
+            <property name="border_width">0</property>
+            <property name="spacing">18</property>
+            <child>
+              <object class="GtkImage" id="icon_image">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="pixel_size">32</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel" id="name_label">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="hexpand">True</property>
+                <property name="xalign">0</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel" id="path_label">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="justify">right</property>
+                <property name="ellipsize">middle</property>
+                <property name="xalign">1</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="eject_button">
+                <property name="visible">False</property>
+                <property name="halign">end</property>
+                <property name="valign">center</property>
+                <property name="tooltip-text" translatable="yes">Unmount</property>
+                <child>
+                  <object class="GtkImage">
+                    <property name="visible">True</property>
+                    <property name="icon_name">media-eject-symbolic</property>
+                    <property name="icon_size">1</property>
+                  </object>
+                </child>
+                <style>
+                  <class name="image-button"/>
+                  <class name="sidebar-button"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">3</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkSpinner" id="busy_spinner">
+                <property name="visible">False</property>
+                <property name="can_focus">False</property>
+                <property name="active">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">4</property>
+              </packing>
+            </child>
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 233daa4..07483c7 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -106,6 +106,7 @@ noinst_PROGRAMS =  $(TEST_PROGS)    \
        testorientable                  \
        testoverlay                     \
        testoverlaystyleclass           \
+       testplacesview                  \
        testprint                       \
        testrecentchooser               \
        testrecentchoosermenu           \
@@ -253,6 +254,7 @@ testappchooserbutton_DEPENDENCIES = $(TEST_DEPS)
 testorientable_DEPENDENCIES = $(TEST_DEPS)
 testoverlay_DEPENDENCIES = $(TEST_DEPS)
 testoverlaystyleclass_DEPENDENCIES = $(TEST_DEPS)
+testplacesview_DEPENDENCIES = $(TEST_DEPS)
 testprint_DEPENDENCIES = $(TEST_DEPS)
 testrecentchooser_DEPENDENCIES = $(TEST_DEPS)
 testrecentchoosermenu_DEPENDENCIES = $(TEST_DEPS)
@@ -397,6 +399,9 @@ testtoolbar_SOURCES =       \
 testmenubutton_SOURCES =       \
        testmenubutton.c
 
+testplacesview_SOURCES =       \
+       testplacesview.c
+
 testprint_SOURCES =            \
        testprint.c             \
        testprintfileoperation.h \
diff --git a/tests/testplacesview.c b/tests/testplacesview.c
new file mode 100644
index 0000000..89da344
--- /dev/null
+++ b/tests/testplacesview.c
@@ -0,0 +1,24 @@
+#include <gtk/gtk.h>
+
+int
+main (int argc, char *argv[])
+{
+  GtkWidget *win;
+  GtkWidget *view;
+
+  gtk_init (&argc, &argv);
+
+  win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_default_size (GTK_WINDOW (win), 400, 600);
+
+  view = gtk_places_view_new ();
+
+  gtk_container_add (GTK_CONTAINER (win), view);
+  gtk_widget_show_all (win);
+
+  g_signal_connect (win, "delete-event", G_CALLBACK (gtk_main_quit), win);
+
+  gtk_main ();
+
+  return 0;
+}