Adding upstream version 43.2.upstream/43.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2635 insertions, 0 deletions

diff --git a/src/gtk/nautilusgtkplacesview.c b/src/gtk/nautilusgtkplacesview.c
new file mode 100644
index 0000000..0d062c9
--- /dev/null
+++ b/src/gtk/nautilusgtkplacesview.c
@@ -0,0 +1,2635 @@
+/* nautilusgtkplacesview.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 Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include "nautilus-enum-types.h"
+
+#include <gio/gio.h>
+#include <gio/gvfs.h>
+#include <gtk/gtk.h>
+
+#include "nautilusgtkplacesviewprivate.h"
+#include "nautilusgtkplacesviewrowprivate.h"
+#include "nautilus-file.h"
+#include "nautilus-file-utilities.h"
+#include "nautilus-properties-window.h"
+
+/*< private >
+ * NautilusGtkPlacesView:
+ *
+ * NautilusGtkPlacesView is a widget that displays a list of persistent drives
+ * such as harddisk partitions and networks.  NautilusGtkPlacesView 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 NautilusGtkPlacesView::open-location signal. This is emitted when the user
+ * selects a location to open in the view.
+ */
+
+struct _NautilusGtkPlacesViewClass
+{
+  GtkBoxClass parent_class;
+
+  void     (* open_location)        (NautilusGtkPlacesView          *view,
+                                     GFile                  *location,
+                                     NautilusGtkPlacesOpenFlags  open_flags);
+
+  void    (* show_error_message)     (NautilusGtkPlacesSidebar      *sidebar,
+                                      const char            *primary,
+                                      const char            *secondary);
+};
+
+struct _NautilusGtkPlacesView
+{
+  GtkBox parent_instance;
+
+  GVolumeMonitor                *volume_monitor;
+  NautilusGtkPlacesOpenFlags             open_flags;
+  NautilusGtkPlacesOpenFlags             current_open_flags;
+
+  GFile                         *server_list_file;
+  GFileMonitor                  *server_list_monitor;
+  GFileMonitor                  *network_monitor;
+
+  GCancellable                  *cancellable;
+
+  char                          *search_query;
+
+  GtkWidget                     *actionbar;
+  GtkWidget                     *address_entry;
+  GtkWidget                     *connect_button;
+  GtkWidget                     *listbox;
+  GtkWidget                     *popup_menu;
+  GtkWidget                     *recent_servers_listbox;
+  GtkWidget                     *recent_servers_popover;
+  GtkWidget                     *recent_servers_stack;
+  GtkWidget                     *stack;
+  GtkWidget                     *server_adresses_popover;
+  GtkWidget                     *available_protocols_grid;
+  GtkWidget                     *network_placeholder;
+  GtkWidget                     *network_placeholder_label;
+
+  GtkSizeGroup                  *path_size_group;
+  GtkSizeGroup                  *space_size_group;
+
+  GtkEntryCompletion            *address_entry_completion;
+  GtkListStore                  *completion_store;
+
+  GCancellable                  *networks_fetching_cancellable;
+
+  NautilusGtkPlacesViewRow              *row_for_action;
+
+  guint                          should_open_location : 1;
+  guint                          should_pulse_entry : 1;
+  guint                          entry_pulse_timeout_id;
+  guint                          connecting_to_server : 1;
+  guint                          mounting_volume : 1;
+  guint                          unmounting_mount : 1;
+  guint                          fetching_networks : 1;
+  guint                          loading : 1;
+  guint                          destroyed : 1;
+};
+
+static void        mount_volume                                  (NautilusGtkPlacesView *view,
+                                                                  GVolume       *volume);
+
+static void        on_eject_button_clicked                       (GtkWidget        *widget,
+                                                                  NautilusGtkPlacesViewRow *row);
+
+static gboolean on_row_popup_menu (GtkWidget *widget,
+                                   GVariant  *args,
+                                   gpointer   user_data);
+
+static void click_cb (GtkGesture *gesture,
+                      int         n_press,
+                      double      x,
+                      double      y,
+                      gpointer    user_data);
+
+static void        populate_servers                              (NautilusGtkPlacesView *view);
+
+static gboolean    nautilus_gtk_places_view_get_fetching_networks         (NautilusGtkPlacesView *view);
+
+static void        nautilus_gtk_places_view_set_fetching_networks         (NautilusGtkPlacesView *view,
+                                                                  gboolean       fetching_networks);
+
+static void        nautilus_gtk_places_view_set_loading                   (NautilusGtkPlacesView *view,
+                                                                  gboolean       loading);
+
+static void        update_loading                                (NautilusGtkPlacesView *view);
+
+G_DEFINE_TYPE (NautilusGtkPlacesView, nautilus_gtk_places_view, GTK_TYPE_BOX)
+
+/* NautilusGtkPlacesView properties & signals */
+enum {
+  PROP_0,
+  PROP_OPEN_FLAGS,
+  PROP_FETCHING_NETWORKS,
+  PROP_LOADING,
+  LAST_PROP
+};
+
+enum {
+  OPEN_LOCATION,
+  SHOW_ERROR_MESSAGE,
+  LAST_SIGNAL
+};
+
+const char *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 (NautilusGtkPlacesView      *view,
+                    GFile              *location,
+                    NautilusGtkPlacesOpenFlags  open_flags)
+{
+  if ((open_flags & view->open_flags) == 0)
+    open_flags = NAUTILUS_GTK_PLACES_OPEN_NORMAL;
+
+  g_signal_emit (view, places_view_signals[OPEN_LOCATION], 0, location, open_flags);
+}
+
+static void
+emit_show_error_message (NautilusGtkPlacesView *view,
+                         char          *primary_message,
+                         char          *secondary_message)
+{
+  g_signal_emit (view, places_view_signals[SHOW_ERROR_MESSAGE],
+                         0, primary_message, secondary_message);
+}
+
+static void
+server_file_changed_cb (NautilusGtkPlacesView *view)
+{
+  populate_servers (view);
+}
+
+static GBookmarkFile *
+server_list_load (NautilusGtkPlacesView *view)
+{
+  GBookmarkFile *bookmarks;
+  GError *error = NULL;
+  char *datadir;
+  char *filename;
+
+  bookmarks = g_bookmark_file_new ();
+  datadir = g_build_filename (g_get_user_config_dir (), "gtk-4.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 (!view->server_list_monitor)
+    {
+      view->server_list_file = g_file_new_for_path (filename);
+
+      if (view->server_list_file)
+        {
+          view->server_list_monitor = g_file_monitor_file (view->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 (view->server_list_monitor,
+                                        "changed",
+                                        G_CALLBACK (server_file_changed_cb),
+                                        view);
+            }
+        }
+
+      g_clear_object (&view->server_list_file);
+    }
+
+  g_free (datadir);
+  g_free (filename);
+
+  return bookmarks;
+}
+
+static void
+server_list_save (GBookmarkFile *bookmarks)
+{
+  char *filename;
+
+  filename = g_build_filename (g_get_user_config_dir (), "gtk-4.0", "servers", NULL);
+  g_bookmark_file_to_file (bookmarks, filename, NULL);
+  g_free (filename);
+}
+
+static void
+server_list_add_server (NautilusGtkPlacesView *view,
+                        GFile         *file)
+{
+  GBookmarkFile *bookmarks;
+  GFileInfo *info;
+  GError *error;
+  char *title;
+  char *uri;
+  GDateTime *now;
+
+  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);
+  now = g_date_time_new_now_utc ();
+  g_bookmark_file_set_visited_date_time (bookmarks, uri, now);
+  g_date_time_unref (now);
+  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 (NautilusGtkPlacesView *view,
+                           const char    *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 (gtk_widget_get_root (widget));
+  if (GTK_IS_WINDOW (toplevel))
+    return GTK_WINDOW (toplevel);
+  else
+    return NULL;
+}
+
+static void
+set_busy_cursor (NautilusGtkPlacesView *view,
+                 gboolean       busy)
+{
+  GtkWidget *widget;
+  GtkWindow *toplevel;
+
+  toplevel = get_toplevel (GTK_WIDGET (view));
+  widget = GTK_WIDGET (toplevel);
+  if (!toplevel || !gtk_widget_get_realized (widget))
+    return;
+
+  if (busy)
+    gtk_widget_set_cursor_from_name (widget, "progress");
+  else
+    gtk_widget_set_cursor (widget, NULL);
+}
+
+/* Activates the given row, with the given flags as parameter */
+static void
+activate_row (NautilusGtkPlacesView      *view,
+              NautilusGtkPlacesViewRow   *row,
+              NautilusGtkPlacesOpenFlags  flags)
+{
+  GVolume *volume;
+  GMount *mount;
+  GFile *file;
+
+  mount = nautilus_gtk_places_view_row_get_mount (row);
+  volume = nautilus_gtk_places_view_row_get_volume (row);
+  file = nautilus_gtk_places_view_row_get_file (row);
+
+  if (file)
+    {
+      emit_open_location (view, file, flags);
+    }
+  else if (mount)
+    {
+      GFile *location = g_mount_get_default_location (mount);
+
+      emit_open_location (view, location, flags);
+
+      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.
+       */
+      view->should_open_location = TRUE;
+
+      nautilus_gtk_places_view_row_set_busy (row, TRUE);
+      mount_volume (view, volume);
+    }
+}
+
+static void update_places (NautilusGtkPlacesView *view);
+
+static void
+nautilus_gtk_places_view_finalize (GObject *object)
+{
+  NautilusGtkPlacesView *view = (NautilusGtkPlacesView *)object;
+
+  if (view->entry_pulse_timeout_id > 0)
+    g_source_remove (view->entry_pulse_timeout_id);
+
+  g_clear_pointer (&view->search_query, g_free);
+  g_clear_object (&view->server_list_file);
+  g_clear_object (&view->server_list_monitor);
+  g_clear_object (&view->volume_monitor);
+  g_clear_object (&view->network_monitor);
+  g_clear_object (&view->cancellable);
+  g_clear_object (&view->networks_fetching_cancellable);
+  g_clear_object (&view->path_size_group);
+  g_clear_object (&view->space_size_group);
+
+  G_OBJECT_CLASS (nautilus_gtk_places_view_parent_class)->finalize (object);
+}
+
+static void
+nautilus_gtk_places_view_dispose (GObject *object)
+{
+  NautilusGtkPlacesView *view = (NautilusGtkPlacesView *)object;
+
+  view->destroyed = 1;
+
+  g_signal_handlers_disconnect_by_func (view->volume_monitor, update_places, object);
+
+  if (view->network_monitor)
+    g_signal_handlers_disconnect_by_func (view->network_monitor, update_places, object);
+
+  if (view->server_list_monitor)
+    g_signal_handlers_disconnect_by_func (view->server_list_monitor, server_file_changed_cb, object);
+
+  g_cancellable_cancel (view->cancellable);
+  g_cancellable_cancel (view->networks_fetching_cancellable);
+  g_clear_pointer (&view->popup_menu, gtk_widget_unparent);
+
+  G_OBJECT_CLASS (nautilus_gtk_places_view_parent_class)->dispose (object);
+}
+
+static void
+nautilus_gtk_places_view_get_property (GObject    *object,
+                              guint       prop_id,
+                              GValue     *value,
+                              GParamSpec *pspec)
+{
+  NautilusGtkPlacesView *self = NAUTILUS_GTK_PLACES_VIEW (object);
+
+  switch (prop_id)
+    {
+    case PROP_LOADING:
+      g_value_set_boolean (value, nautilus_gtk_places_view_get_loading (self));
+      break;
+
+    case PROP_OPEN_FLAGS:
+      g_value_set_flags (value, nautilus_gtk_places_view_get_open_flags (self));
+      break;
+
+    case PROP_FETCHING_NETWORKS:
+      g_value_set_boolean (value, nautilus_gtk_places_view_get_fetching_networks (self));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+nautilus_gtk_places_view_set_property (GObject      *object,
+                              guint         prop_id,
+                              const GValue *value,
+                              GParamSpec   *pspec)
+{
+  NautilusGtkPlacesView *self = NAUTILUS_GTK_PLACES_VIEW (object);
+
+  switch (prop_id)
+    {
+    case PROP_OPEN_FLAGS:
+      nautilus_gtk_places_view_set_open_flags (self, g_value_get_flags (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static gboolean
+is_external_volume (GVolume *volume)
+{
+  gboolean is_external;
+  GDrive *drive;
+  char *id;
+
+  drive = g_volume_get_drive (volume);
+  id = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_CLASS);
+
+  is_external = g_volume_can_eject (volume);
+
+  /* NULL volume identifier only happens on removable devices */
+  is_external |= !id;
+
+  if (drive)
+    is_external |= g_drive_is_removable (drive);
+
+  g_clear_object (&drive);
+  g_free (id);
+
+  return is_external;
+}
+
+typedef struct
+{
+  char          *uri;
+  NautilusGtkPlacesView *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 (NautilusGtkPlacesView *view)
+{
+  GBookmarkFile *server_list;
+  GtkWidget *child;
+  char **uris;
+  gsize num_uris;
+  int i;
+
+  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 (view->recent_servers_stack),
+                                    num_uris > 0 ? "list" : "empty");
+
+  if (!uris)
+    {
+      g_bookmark_file_free (server_list);
+      return;
+    }
+
+  /* clear previous items */
+  while ((child = gtk_widget_get_first_child (GTK_WIDGET (view->recent_servers_listbox))))
+    gtk_list_box_remove (GTK_LIST_BOX (view->recent_servers_listbox), child);
+
+  gtk_list_store_clear (view->completion_store);
+
+  for (i = 0; i < num_uris; i++)
+    {
+      RemoveServerData *data;
+      GtkTreeIter iter;
+      GtkWidget *row;
+      GtkWidget *grid;
+      GtkWidget *button;
+      GtkWidget *label;
+      char *name;
+      char *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 (view->completion_store, &iter);
+      gtk_list_store_set (view->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,
+                           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_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
+
+      /* 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_widget_add_css_class (label, "dim-label");
+      gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
+
+      /* remove button */
+      button = gtk_button_new_from_icon_name ("window-close-symbolic");
+      gtk_widget_set_halign (button, GTK_ALIGN_END);
+      gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
+      gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
+      gtk_widget_add_css_class (button, "sidebar-button");
+      gtk_grid_attach (GTK_GRID (grid), button, 1, 0, 1, 2);
+
+      gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), grid);
+      gtk_list_box_insert (GTK_LIST_BOX (view->recent_servers_listbox), row, -1);
+
+      /* 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);
+
+      g_free (name);
+    }
+
+  g_strfreev (uris);
+  g_bookmark_file_free (server_list);
+}
+
+static void
+update_view_mode (NautilusGtkPlacesView *view)
+{
+  GtkWidget *child;
+  gboolean show_listbox;
+
+  show_listbox = FALSE;
+
+  /* drives */
+  for (child = gtk_widget_get_first_child (GTK_WIDGET (view->listbox));
+       child != NULL;
+       child = gtk_widget_get_next_sibling (child))
+    {
+      /* GtkListBox filter rows by changing their GtkWidget::child-visible property */
+      if (gtk_widget_get_child_visible (child))
+        {
+          show_listbox = TRUE;
+          break;
+        }
+    }
+
+  if (!show_listbox &&
+      view->search_query &&
+      view->search_query[0] != '\0')
+    {
+        gtk_stack_set_visible_child_name (GTK_STACK (view->stack), "empty-search");
+    }
+  else
+    {
+      gtk_stack_set_visible_child_name (GTK_STACK (view->stack), "browse");
+    }
+}
+
+static void
+insert_row (NautilusGtkPlacesView *view,
+            GtkWidget     *row,
+            gboolean       is_network)
+{
+  GtkEventController *controller;
+  GtkShortcutTrigger *trigger;
+  GtkShortcutAction *action;
+  GtkShortcut *shortcut;
+  GtkGesture *gesture;
+
+  g_object_set_data (G_OBJECT (row), "is-network", GINT_TO_POINTER (is_network));
+
+  controller = gtk_shortcut_controller_new ();
+  trigger = gtk_alternative_trigger_new (gtk_keyval_trigger_new (GDK_KEY_F10, GDK_SHIFT_MASK),
+                                         gtk_keyval_trigger_new (GDK_KEY_Menu, 0));
+  action = gtk_callback_action_new (on_row_popup_menu, row, NULL);
+  shortcut = gtk_shortcut_new (trigger, action);
+  gtk_shortcut_controller_add_shortcut (GTK_SHORTCUT_CONTROLLER (controller), shortcut);
+  gtk_widget_add_controller (GTK_WIDGET (row), controller);
+
+  gesture = gtk_gesture_click_new ();
+  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
+  g_signal_connect (gesture, "pressed", G_CALLBACK (click_cb), row);
+  gtk_widget_add_controller (row, GTK_EVENT_CONTROLLER (gesture));
+
+  g_signal_connect (nautilus_gtk_places_view_row_get_eject_button (NAUTILUS_GTK_PLACES_VIEW_ROW (row)),
+                    "clicked",
+                    G_CALLBACK (on_eject_button_clicked),
+                    row);
+
+  nautilus_gtk_places_view_row_set_path_size_group (NAUTILUS_GTK_PLACES_VIEW_ROW (row), view->path_size_group);
+  nautilus_gtk_places_view_row_set_space_size_group (NAUTILUS_GTK_PLACES_VIEW_ROW (row), view->space_size_group);
+
+  gtk_list_box_insert (GTK_LIST_BOX (view->listbox), row, -1);
+}
+
+static void
+add_volume (NautilusGtkPlacesView *view,
+            GVolume       *volume)
+{
+  gboolean is_network;
+  GMount *mount;
+  GFile *root;
+  GIcon *icon;
+  char *identifier;
+  char *name;
+  char *path;
+
+  if (is_external_volume (volume))
+    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_default_location (mount) : NULL;
+  icon = g_volume_get_icon (volume);
+  name = g_volume_get_name (volume);
+  path = !is_network ? g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE) : NULL;
+
+  if (!mount || !g_mount_is_shadowed (mount))
+    {
+      GtkWidget *row;
+
+      row = g_object_new (NAUTILUS_TYPE_GTK_PLACES_VIEW_ROW,
+                          "icon", icon,
+                          "name", name,
+                          "path", path ? path : "",
+                          "volume", volume,
+                          "mount", mount,
+                          "file", NULL,
+                          "is-network", is_network,
+                          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 (NautilusGtkPlacesView *view,
+           GMount        *mount)
+{
+  gboolean is_network;
+  GFile *root;
+  GIcon *icon;
+  char *name;
+  char *path;
+  char *uri;
+  char *schema;
+
+  icon = g_mount_get_icon (mount);
+  name = g_mount_get_name (mount);
+  root = g_mount_get_default_location (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 (is_network)
+    g_clear_pointer (&path, g_free);
+
+  if (!g_mount_is_shadowed (mount))
+    {
+      GtkWidget *row;
+
+      row = g_object_new (NAUTILUS_TYPE_GTK_PLACES_VIEW_ROW,
+                          "icon", icon,
+                          "name", name,
+                          "path", path ? path : "",
+                          "volume", NULL,
+                          "mount", mount,
+                          "file", NULL,
+                          "is-network", is_network,
+                          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 (NautilusGtkPlacesView *view,
+           GDrive        *drive)
+{
+  GList *volumes;
+  GList *l;
+
+  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
+add_file (NautilusGtkPlacesView *view,
+          GFile         *file,
+          GIcon         *icon,
+          const char    *display_name,
+          const char    *path,
+          gboolean       is_network)
+{
+  GtkWidget *row;
+  row = g_object_new (NAUTILUS_TYPE_GTK_PLACES_VIEW_ROW,
+                      "icon", icon,
+                      "name", display_name,
+                      "path", path,
+                      "volume", NULL,
+                      "mount", NULL,
+                      "file", file,
+                      "is_network", is_network,
+                      NULL);
+
+  insert_row (view, row, is_network);
+}
+
+static gboolean
+has_networks (NautilusGtkPlacesView *view)
+{
+  GtkWidget *child;
+  gboolean has_network = FALSE;
+
+  for (child = gtk_widget_get_first_child (GTK_WIDGET (view->listbox));
+       child != NULL;
+       child = gtk_widget_get_next_sibling (child))
+    {
+      if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (child), "is-network")) &&
+          g_object_get_data (G_OBJECT (child), "is-placeholder") == NULL)
+      {
+        has_network = TRUE;
+        break;
+      }
+    }
+
+  return has_network;
+}
+
+static void
+update_network_state (NautilusGtkPlacesView *view)
+{
+  if (view->network_placeholder == NULL)
+    {
+      view->network_placeholder = gtk_list_box_row_new ();
+      view->network_placeholder_label = gtk_label_new ("");
+      gtk_label_set_xalign (GTK_LABEL (view->network_placeholder_label), 0.0);
+      gtk_widget_set_margin_start (view->network_placeholder_label, 12);
+      gtk_widget_set_margin_end (view->network_placeholder_label, 12);
+      gtk_widget_set_margin_top (view->network_placeholder_label, 6);
+      gtk_widget_set_margin_bottom (view->network_placeholder_label, 6);
+      gtk_widget_set_hexpand (view->network_placeholder_label, TRUE);
+      gtk_widget_set_sensitive (view->network_placeholder, FALSE);
+      gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (view->network_placeholder),
+                                  view->network_placeholder_label);
+      g_object_set_data (G_OBJECT (view->network_placeholder),
+                         "is-network", GINT_TO_POINTER (TRUE));
+      /* mark the row as placeholder, so it always goes first */
+      g_object_set_data (G_OBJECT (view->network_placeholder),
+                         "is-placeholder", GINT_TO_POINTER (TRUE));
+      gtk_list_box_insert (GTK_LIST_BOX (view->listbox), view->network_placeholder, -1);
+    }
+
+  if (nautilus_gtk_places_view_get_fetching_networks (view))
+    {
+      /* only show a placeholder with a message if the list is empty.
+       * otherwise just show the spinner in the header */
+      if (!has_networks (view))
+        {
+          gtk_widget_show (view->network_placeholder);
+          gtk_label_set_text (GTK_LABEL (view->network_placeholder_label),
+                              _("Searching for network locations"));
+        }
+    }
+  else if (!has_networks (view))
+    {
+      gtk_widget_show (view->network_placeholder);
+      gtk_label_set_text (GTK_LABEL (view->network_placeholder_label),
+                          _("No network locations found"));
+    }
+  else
+    {
+      gtk_widget_hide (view->network_placeholder);
+    }
+}
+
+static void
+monitor_network (NautilusGtkPlacesView *view)
+{
+  GFile *network_file;
+  GError *error;
+
+  if (view->network_monitor)
+    return;
+
+  error = NULL;
+  network_file = g_file_new_for_uri ("network:///");
+  view->network_monitor = g_file_monitor (network_file,
+                                          G_FILE_MONITOR_NONE,
+                                          NULL,
+                                          &error);
+
+  g_clear_object (&network_file);
+
+  if (error)
+    {
+      g_warning ("Error monitoring network: %s", error->message);
+      g_clear_error (&error);
+      return;
+    }
+
+  g_signal_connect_swapped (view->network_monitor,
+                            "changed",
+                            G_CALLBACK (update_places),
+                            view);
+}
+
+static void
+populate_networks (NautilusGtkPlacesView   *view,
+                   GFileEnumerator *enumerator,
+                   GList           *detected_networks)
+{
+  GList *l;
+  GFile *file;
+  GFile *activatable_file;
+  char *uri;
+  GFileType type;
+  GIcon *icon;
+  char *display_name;
+
+  for (l = detected_networks; l != NULL; l = l->next)
+    {
+      file = g_file_enumerator_get_child (enumerator, l->data);
+      type = g_file_info_get_file_type (l->data);
+      if (type == G_FILE_TYPE_SHORTCUT || type == G_FILE_TYPE_MOUNTABLE)
+        uri = g_file_info_get_attribute_as_string (l->data, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI);
+      else
+        uri = g_file_get_uri (file);
+      activatable_file = g_file_new_for_uri (uri);
+      display_name = g_file_info_get_attribute_as_string (l->data, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME);
+      icon = g_file_info_get_icon (l->data);
+
+      add_file (view, activatable_file, icon, display_name, NULL, TRUE);
+
+      g_free (uri);
+      g_free (display_name);
+      g_clear_object (&file);
+      g_clear_object (&activatable_file);
+    }
+}
+
+static void
+network_enumeration_next_files_finished (GObject      *source_object,
+                                         GAsyncResult *res,
+                                         gpointer      user_data)
+{
+  NautilusGtkPlacesView *view;
+  GList *detected_networks;
+  GError *error;
+
+  view = NAUTILUS_GTK_PLACES_VIEW (user_data);
+  error = NULL;
+
+  detected_networks = g_file_enumerator_next_files_finish (G_FILE_ENUMERATOR (source_object),
+                                                           res, &error);
+
+  if (error)
+    {
+      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_clear_error (&error);
+          g_object_unref (view);
+          return;
+        }
+
+      g_warning ("Failed to fetch network locations: %s", error->message);
+      g_clear_error (&error);
+    }
+  else
+    {
+      nautilus_gtk_places_view_set_fetching_networks (view, FALSE);
+      populate_networks (view, G_FILE_ENUMERATOR (source_object), detected_networks);
+
+      g_list_free_full (detected_networks, g_object_unref);
+    }
+
+  update_network_state (view);
+  monitor_network (view);
+  update_loading (view);
+
+  g_object_unref (view);
+}
+
+static void
+network_enumeration_finished (GObject      *source_object,
+                              GAsyncResult *res,
+                              gpointer      user_data)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (user_data);
+  GFileEnumerator *enumerator;
+  GError *error;
+
+  error = NULL;
+  enumerator = g_file_enumerate_children_finish (G_FILE (source_object), res, &error);
+
+  if (error)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) &&
+          !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED))
+        g_warning ("Failed to fetch network locations: %s", error->message);
+
+      g_clear_error (&error);
+      g_object_unref (view);
+    }
+  else
+    {
+      g_file_enumerator_next_files_async (enumerator,
+                                          G_MAXINT32,
+                                          G_PRIORITY_DEFAULT,
+                                          view->networks_fetching_cancellable,
+                                          network_enumeration_next_files_finished,
+                                          user_data);
+      g_object_unref (enumerator);
+    }
+}
+
+static void
+fetch_networks (NautilusGtkPlacesView *view)
+{
+  GFile *network_file;
+  const char * const *supported_uris;
+  gboolean found;
+
+  supported_uris = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
+
+  for (found = FALSE; !found && supported_uris && supported_uris[0]; supported_uris++)
+    if (g_strcmp0 (supported_uris[0], "network") == 0)
+      found = TRUE;
+
+  if (!found)
+    return;
+
+  network_file = g_file_new_for_uri ("network:///");
+
+  g_cancellable_cancel (view->networks_fetching_cancellable);
+  g_clear_object (&view->networks_fetching_cancellable);
+  view->networks_fetching_cancellable = g_cancellable_new ();
+  nautilus_gtk_places_view_set_fetching_networks (view, TRUE);
+  update_network_state (view);
+
+  g_object_ref (view);
+  g_file_enumerate_children_async (network_file,
+                                   "standard::type,standard::target-uri,standard::name,standard::display-name,standard::icon",
+                                   G_FILE_QUERY_INFO_NONE,
+                                   G_PRIORITY_DEFAULT,
+                                   view->networks_fetching_cancellable,
+                                   network_enumeration_finished,
+                                   view);
+
+  g_clear_object (&network_file);
+}
+
+static void
+update_places (NautilusGtkPlacesView *view)
+{
+  GList *mounts;
+  GList *volumes;
+  GList *drives;
+  GList *l;
+  GIcon *icon;
+  GFile *file;
+  GtkWidget *child;
+  gchar *osname;
+
+  /* Clear all previously added items */
+  while ((child = gtk_widget_get_first_child (GTK_WIDGET (view->listbox))))
+    gtk_list_box_remove (GTK_LIST_BOX (view->listbox), child);
+
+  view->network_placeholder = NULL;
+  /* Inform clients that we started loading */
+  nautilus_gtk_places_view_set_loading (view, TRUE);
+
+  /* Add "Computer" row */
+  file = g_file_new_for_path ("/");
+  icon = g_themed_icon_new_with_default_fallbacks ("drive-harddisk");
+  osname = g_get_os_info (G_OS_INFO_KEY_NAME);
+
+  add_file (view, file, icon, ((osname != NULL) ? osname : _("Operating System")), "/", FALSE);
+
+  g_clear_object (&file);
+  g_clear_object (&icon);
+  g_free (osname);
+
+  /* Add currently connected drives */
+  drives = g_volume_monitor_get_connected_drives (view->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 (view->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 have no volume, such as /etc/mtab mounts, ftp, sftp, etc.
+   */
+  mounts = g_volume_monitor_get_mounts (view->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);
+
+  /* fetch networks and add them asynchronously */
+  fetch_networks (view);
+
+  update_view_mode (view);
+  /* Check whether we still are in a loading state */
+  update_loading (view);
+}
+
+static void
+server_mount_ready_cb (GObject      *source_file,
+                       GAsyncResult *res,
+                       gpointer      user_data)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (user_data);
+  gboolean should_show;
+  GError *error;
+  GFile *location;
+
+  location = G_FILE (source_file);
+  should_show = TRUE;
+  error = NULL;
+
+  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);
+        }
+
+      /* The operation got cancelled by the user and or the error
+         has been handled already. */
+      g_clear_error (&error);
+    }
+
+  if (view->destroyed)
+    {
+      g_object_unref (view);
+      return;
+    }
+
+  view->should_pulse_entry = FALSE;
+  gtk_entry_set_progress_fraction (GTK_ENTRY (view->address_entry), 0);
+
+  /* Restore from Cancel to Connect */
+  gtk_button_set_label (GTK_BUTTON (view->connect_button), _("Con_nect"));
+  gtk_widget_set_sensitive (view->address_entry, TRUE);
+  view->connecting_to_server = FALSE;
+
+  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_editable_set_text (GTK_EDITABLE (view->address_entry), "");
+
+      if (view->should_open_location)
+        {
+          GMount *mount;
+          GFile *root;
+
+          /*
+           * If the mount is not found at this point, it is probably user-
+           * invisible, which happens e.g for smb-browse, but the location
+           * should be opened anyway...
+           */
+          mount = g_file_find_enclosing_mount (location, view->cancellable, NULL);
+          if (mount)
+            {
+              root = g_mount_get_default_location (mount);
+
+              emit_open_location (view, root, view->open_flags);
+
+              g_object_unref (root);
+              g_object_unref (mount);
+            }
+          else
+            {
+              emit_open_location (view, location, view->open_flags);
+            }
+        }
+    }
+
+  update_places (view);
+  g_object_unref (view);
+}
+
+static void
+volume_mount_ready_cb (GObject      *source_volume,
+                       GAsyncResult *res,
+                       gpointer      user_data)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (user_data);
+  gboolean should_show;
+  GVolume *volume;
+  GError *error;
+
+  volume = G_VOLUME (source_volume);
+  should_show = TRUE;
+  error = NULL;
+
+  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 (NAUTILUS_GTK_PLACES_VIEW (user_data), _("Unable to access location"), error->message);
+          should_show = FALSE;
+        }
+
+      /* The operation got cancelled by the user and or the error
+         has been handled already. */
+      g_clear_error (&error);
+    }
+
+  if (view->destroyed)
+    {
+      g_object_unref(view);
+      return;
+    }
+
+  view->mounting_volume = FALSE;
+  update_loading (view);
+
+  if (should_show)
+    {
+      GMount *mount;
+      GFile *root;
+
+      mount = g_volume_get_mount (volume);
+      root = g_mount_get_default_location (mount);
+
+      if (view->should_open_location)
+        emit_open_location (NAUTILUS_GTK_PLACES_VIEW (user_data), root, view->open_flags);
+
+      g_object_unref (mount);
+      g_object_unref (root);
+    }
+
+  update_places (view);
+  g_object_unref (view);
+}
+
+static void
+unmount_ready_cb (GObject      *source_mount,
+                  GAsyncResult *res,
+                  gpointer      user_data)
+{
+  NautilusGtkPlacesView *view;
+  GMount *mount;
+  GError *error;
+
+  view = NAUTILUS_GTK_PLACES_VIEW (user_data);
+  mount = G_MOUNT (source_mount);
+  error = NULL;
+
+  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);
+    }
+
+  if (view->destroyed) {
+    g_object_unref (view);
+    return;
+  }
+
+  view->row_for_action = NULL;
+  view->unmounting_mount = FALSE;
+  update_loading (view);
+
+  g_object_unref (view);
+}
+
+static gboolean
+pulse_entry_cb (gpointer user_data)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (user_data);
+
+  if (view->destroyed)
+    {
+      view->entry_pulse_timeout_id = 0;
+
+      return G_SOURCE_REMOVE;
+    }
+  else if (view->should_pulse_entry)
+    {
+      gtk_entry_progress_pulse (GTK_ENTRY (view->address_entry));
+
+      return G_SOURCE_CONTINUE;
+    }
+  else
+    {
+      gtk_entry_set_progress_fraction (GTK_ENTRY (view->address_entry), 0);
+      view->entry_pulse_timeout_id = 0;
+
+      return G_SOURCE_REMOVE;
+    }
+}
+
+static void
+unmount_mount (NautilusGtkPlacesView *view,
+               GMount        *mount)
+{
+  GMountOperation *operation;
+  GtkWidget *toplevel;
+
+  toplevel = GTK_WIDGET (gtk_widget_get_root (GTK_WIDGET (view)));
+
+  g_cancellable_cancel (view->cancellable);
+  g_clear_object (&view->cancellable);
+  view->cancellable = g_cancellable_new ();
+
+  view->unmounting_mount = TRUE;
+  update_loading (view);
+
+  g_object_ref (view);
+
+  operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
+  g_mount_unmount_with_operation (mount,
+                                  0,
+                                  operation,
+                                  view->cancellable,
+                                  unmount_ready_cb,
+                                  view);
+  g_object_unref (operation);
+}
+
+static void
+mount_server (NautilusGtkPlacesView *view,
+              GFile         *location)
+{
+  GMountOperation *operation;
+  GtkWidget *toplevel;
+
+  g_cancellable_cancel (view->cancellable);
+  g_clear_object (&view->cancellable);
+  /* User cliked when the operation was ongoing, so wanted to cancel it */
+  if (view->connecting_to_server)
+    return;
+
+  view->cancellable = g_cancellable_new ();
+  toplevel = GTK_WIDGET (gtk_widget_get_root (GTK_WIDGET (view)));
+  operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
+
+  view->should_pulse_entry = TRUE;
+  gtk_entry_set_progress_pulse_step (GTK_ENTRY (view->address_entry), 0.1);
+  gtk_entry_set_progress_fraction (GTK_ENTRY (view->address_entry), 0.1);
+  /* Allow to cancel the operation */
+  gtk_button_set_label (GTK_BUTTON (view->connect_button), _("Cance_l"));
+  gtk_widget_set_sensitive (view->address_entry, FALSE);
+  view->connecting_to_server = TRUE;
+  update_loading (view);
+
+  if (view->entry_pulse_timeout_id == 0)
+    view->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);
+
+  /* make sure we keep the view around for as long as we are running */
+  g_object_ref (view);
+
+  g_file_mount_enclosing_volume (location,
+                                 0,
+                                 operation,
+                                 view->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 (NautilusGtkPlacesView *view,
+              GVolume       *volume)
+{
+  GMountOperation *operation;
+  GtkWidget *toplevel;
+
+  toplevel = GTK_WIDGET (gtk_widget_get_root (GTK_WIDGET (view)));
+  operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
+
+  g_cancellable_cancel (view->cancellable);
+  g_clear_object (&view->cancellable);
+  view->cancellable = g_cancellable_new ();
+
+  view->mounting_volume = TRUE;
+  update_loading (view);
+
+  g_mount_operation_set_password_save (operation, G_PASSWORD_SAVE_FOR_SESSION);
+
+  /* make sure we keep the view around for as long as we are running */
+  g_object_ref (view);
+
+  g_volume_mount (volume,
+                  0,
+                  operation,
+                  view->cancellable,
+                  volume_mount_ready_cb,
+                  view);
+
+  /* unref operation here - g_file_mount_enclosing_volume() does ref for itself */
+  g_object_unref (operation);
+}
+
+static void
+open_cb (GtkWidget  *widget,
+         const char *action_name,
+         GVariant   *parameter)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (widget);
+  NautilusGtkPlacesOpenFlags flags = NAUTILUS_GTK_PLACES_OPEN_NORMAL;
+
+  if (view->row_for_action == NULL)
+    return;
+
+  if (strcmp (action_name, "location.open") == 0)
+    flags = NAUTILUS_GTK_PLACES_OPEN_NORMAL;
+  else if (strcmp (action_name, "location.open-tab") == 0)
+    flags = NAUTILUS_GTK_PLACES_OPEN_NEW_TAB;
+  else if (strcmp (action_name, "location.open-window") == 0)
+    flags = NAUTILUS_GTK_PLACES_OPEN_NEW_WINDOW;
+
+  activate_row (view, view->row_for_action, flags);
+}
+
+static void
+properties_cb (GtkWidget  *widget,
+               const char *action_name,
+               GVariant   *parameter)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (widget);
+  GList *list;
+  GMount *mount;
+  g_autoptr (GFile) location = NULL;
+  NautilusFile *file;
+
+  if (view->row_for_action == NULL)
+    return;
+
+  file = NULL;
+  mount = nautilus_gtk_places_view_row_get_mount (view->row_for_action);
+
+  if (mount)
+    {
+      location = g_mount_get_root (mount);
+      file = nautilus_file_get (location);
+    }
+  else
+    file = nautilus_file_get (nautilus_gtk_places_view_row_get_file (view->row_for_action));
+
+  if (file)
+    {
+      list = g_list_append (NULL, file);
+      nautilus_properties_window_present (list, widget, NULL, NULL, NULL);
+
+      nautilus_file_list_unref (list);
+    }
+}
+
+static void
+mount_cb (GtkWidget  *widget,
+          const char *action_name,
+          GVariant   *parameter)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (widget);
+  GVolume *volume;
+
+  if (view->row_for_action == NULL)
+    return;
+
+  volume = nautilus_gtk_places_view_row_get_volume (view->row_for_action);
+
+  /*
+   * When the mount item is activated, it's expected that
+   * the volume only gets mounted, without opening it after
+   * the operation is complete.
+   */
+  view->should_open_location = FALSE;
+
+  nautilus_gtk_places_view_row_set_busy (view->row_for_action, TRUE);
+  mount_volume (view, volume);
+}
+
+static void
+unmount_cb (GtkWidget  *widget,
+            const char *action_name,
+            GVariant   *parameter)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (widget);
+  GMount *mount;
+
+  if (view->row_for_action == NULL)
+    return;
+
+  mount = nautilus_gtk_places_view_row_get_mount (view->row_for_action);
+
+  nautilus_gtk_places_view_row_set_busy (view->row_for_action, TRUE);
+
+  unmount_mount (view, mount);
+}
+
+static void
+attach_protocol_row_to_grid (GtkGrid     *grid,
+                             const char *protocol_name,
+                             const char *protocol_prefix)
+{
+  GtkWidget *name_label;
+  GtkWidget *prefix_label;
+
+  name_label = gtk_label_new (protocol_name);
+  gtk_widget_set_halign (name_label, GTK_ALIGN_START);
+  gtk_grid_attach_next_to (grid, name_label, NULL, GTK_POS_BOTTOM, 1, 1);
+
+  prefix_label = gtk_label_new (protocol_prefix);
+  gtk_widget_set_halign (prefix_label, GTK_ALIGN_START);
+  gtk_grid_attach_next_to (grid, prefix_label, name_label, GTK_POS_RIGHT, 1, 1);
+}
+
+static void
+populate_available_protocols_grid (GtkGrid *grid)
+{
+  const char * const *supported_protocols;
+  gboolean has_any = FALSE;
+
+  supported_protocols = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
+
+  if (g_strv_contains (supported_protocols, "afp"))
+    {
+      attach_protocol_row_to_grid (grid, _("AppleTalk"), "afp://");
+      has_any = TRUE;
+    }
+
+  if (g_strv_contains (supported_protocols, "ftp"))
+    {
+      attach_protocol_row_to_grid (grid, _("File Transfer Protocol"),
+                                   /* Translators: do not translate ftp:// and ftps:// */
+                                   _("ftp:// or ftps://"));
+      has_any = TRUE;
+    }
+
+  if (g_strv_contains (supported_protocols, "nfs"))
+    {
+      attach_protocol_row_to_grid (grid, _("Network File System"), "nfs://");
+      has_any = TRUE;
+    }
+
+  if (g_strv_contains (supported_protocols, "smb"))
+    {
+      attach_protocol_row_to_grid (grid, _("Samba"), "smb://");
+      has_any = TRUE;
+    }
+
+  if (g_strv_contains (supported_protocols, "ssh"))
+    {
+      attach_protocol_row_to_grid (grid, _("SSH File Transfer Protocol"),
+                                   /* Translators: do not translate sftp:// and ssh:// */
+                                   _("sftp:// or ssh://"));
+      has_any = TRUE;
+    }
+
+  if (g_strv_contains (supported_protocols, "dav"))
+    {
+      attach_protocol_row_to_grid (grid, _("WebDAV"),
+                                   /* Translators: do not translate dav:// and davs:// */
+                                   _("dav:// or davs://"));
+      has_any = TRUE;
+    }
+
+  if (!has_any)
+    gtk_widget_hide (GTK_WIDGET (grid));
+}
+
+static GMenuModel *
+get_menu_model (void)
+{
+  GMenu *menu;
+  GMenu *section;
+  GMenuItem *item;
+
+  menu = g_menu_new ();
+  section = g_menu_new ();
+  item = g_menu_item_new (_("_Open"), "location.open");
+  g_menu_append_item (section, item);
+  g_object_unref (item);
+
+  item = g_menu_item_new (_("Open in New _Tab"), "location.open-tab");
+  g_menu_item_set_attribute (item, "hidden-when", "s", "action-disabled");
+  g_menu_append_item (section, item);
+  g_object_unref (item);
+
+  item = g_menu_item_new (_("Open in New _Window"), "location.open-window");
+  g_menu_item_set_attribute (item, "hidden-when", "s", "action-disabled");
+  g_menu_append_item (section, item);
+  g_object_unref (item);
+
+  g_menu_append_section (menu, NULL, G_MENU_MODEL (section));
+  g_object_unref (section);
+
+  section = g_menu_new ();
+  item = g_menu_item_new (_("_Disconnect"), "location.disconnect");
+  g_menu_item_set_attribute (item, "hidden-when", "s", "action-disabled");
+  g_menu_append_item (section, item);
+  g_object_unref (item);
+
+  item = g_menu_item_new (_("_Unmount"), "location.unmount");
+  g_menu_item_set_attribute (item, "hidden-when", "s", "action-disabled");
+  g_menu_append_item (section, item);
+  g_object_unref (item);
+
+
+  item = g_menu_item_new (_("_Connect"), "location.connect");
+  g_menu_item_set_attribute (item, "hidden-when", "s", "action-disabled");
+  g_menu_append_item (section, item);
+  g_object_unref (item);
+
+  item = g_menu_item_new (_("_Mount"), "location.mount");
+  g_menu_item_set_attribute (item, "hidden-when", "s", "action-disabled");
+  g_menu_append_item (section, item);
+  g_object_unref (item);
+
+  item = g_menu_item_new (_("_Properties"), "location.properties");
+  g_menu_item_set_attribute (item, "hidden-when", "s", "action-disabled");
+  g_menu_append_item (section, item);
+  g_object_unref (item);
+
+  g_menu_append_section (menu, NULL, G_MENU_MODEL (section));
+  g_object_unref (section);
+
+  return G_MENU_MODEL (menu);
+}
+
+static void
+_popover_set_pointing_to_widget (GtkPopover *popover,
+                                 GtkWidget  *target)
+{
+  GtkWidget *parent;
+  double x, y, w, h;
+
+  parent = gtk_widget_get_parent (GTK_WIDGET (popover));
+
+  if (!gtk_widget_translate_coordinates (target, parent, 0, 0, &x, &y))
+    return;
+
+  w = gtk_widget_get_allocated_width (GTK_WIDGET (target));
+  h = gtk_widget_get_allocated_height (GTK_WIDGET (target));
+
+  gtk_popover_set_pointing_to (popover, &(GdkRectangle){x, y, w, h});
+}
+
+static gboolean
+real_popup_menu (GtkWidget *widget,
+                 double     x,
+                 double     y)
+{
+  NautilusGtkPlacesViewRow *row = NAUTILUS_GTK_PLACES_VIEW_ROW (widget);
+  NautilusGtkPlacesView *view;
+  GMount *mount;
+  GFile *file;
+  gboolean is_root, is_network;
+  double x_in_view, y_in_view;
+
+  view = NAUTILUS_GTK_PLACES_VIEW (gtk_widget_get_ancestor (GTK_WIDGET (row), NAUTILUS_TYPE_GTK_PLACES_VIEW));
+
+  mount = nautilus_gtk_places_view_row_get_mount (row);
+  file = nautilus_gtk_places_view_row_get_file (row);
+  is_root = file && nautilus_is_root_directory (file);
+  is_network = nautilus_gtk_places_view_row_get_is_network (row);
+
+  gtk_widget_action_set_enabled (GTK_WIDGET (view), "location.disconnect",
+                                 !file && mount && is_network);
+  gtk_widget_action_set_enabled (GTK_WIDGET (view), "location.unmount",
+                                 !file && mount && !is_network);
+  gtk_widget_action_set_enabled (GTK_WIDGET (view), "location.connect",
+                                 !file && !mount && is_network);
+  gtk_widget_action_set_enabled (GTK_WIDGET (view), "location.mount",
+                                 !file && !mount && !is_network);
+  gtk_widget_action_set_enabled (GTK_WIDGET (view), "location.properties",
+                                 (is_root ||
+                                  (mount && !(file && is_network))));
+
+  if (!view->popup_menu)
+    {
+      GMenuModel *model = get_menu_model ();
+
+      view->popup_menu = gtk_popover_menu_new_from_model (model);
+
+      gtk_popover_set_has_arrow (GTK_POPOVER (view->popup_menu), FALSE);
+      gtk_widget_set_parent (view->popup_menu, GTK_WIDGET (view));
+      gtk_widget_set_halign (view->popup_menu, GTK_ALIGN_START);
+
+      g_object_unref (model);
+    }
+
+  if (view->row_for_action)
+    g_object_set_data (G_OBJECT (view->row_for_action), "menu", NULL);
+
+  if (x == -1 && y == -1)
+    _popover_set_pointing_to_widget (GTK_POPOVER (view->popup_menu), widget);
+  else
+    {
+      gtk_widget_translate_coordinates (widget, GTK_WIDGET (view),
+                                        x, y, &x_in_view, &y_in_view);
+      gtk_popover_set_pointing_to (GTK_POPOVER (view->popup_menu),
+                                   &(GdkRectangle){x_in_view, y_in_view, 0, 0});
+    }
+
+  view->row_for_action = row;
+  if (view->row_for_action)
+    g_object_set_data (G_OBJECT (view->row_for_action), "menu", view->popup_menu);
+
+  gtk_popover_popup (GTK_POPOVER (view->popup_menu));
+
+  return TRUE;
+}
+
+static gboolean
+on_row_popup_menu (GtkWidget *widget,
+                   GVariant  *args,
+                   gpointer   user_data)
+{
+  return real_popup_menu (widget, -1, -1);
+}
+
+static void
+click_cb (GtkGesture *gesture,
+          int         n_press,
+          double      x,
+          double      y,
+          gpointer    user_data)
+{
+  real_popup_menu (GTK_WIDGET (user_data), x, y);
+}
+
+static gboolean
+on_key_press_event (GtkEventController *controller,
+                    guint               keyval,
+                    guint               keycode,
+                    GdkModifierType     state,
+                    NautilusGtkPlacesView      *view)
+{
+  GdkModifierType modifiers;
+
+  modifiers = gtk_accelerator_get_default_mod_mask ();
+
+  if (keyval == GDK_KEY_Return ||
+      keyval == GDK_KEY_KP_Enter ||
+      keyval == GDK_KEY_ISO_Enter ||
+      keyval == GDK_KEY_space)
+    {
+      GtkWidget *focus_widget;
+      GtkWindow *toplevel;
+
+      view->current_open_flags = NAUTILUS_GTK_PLACES_OPEN_NORMAL;
+      toplevel = get_toplevel (GTK_WIDGET (view));
+
+      if (!toplevel)
+        return FALSE;
+
+      focus_widget = gtk_root_get_focus (GTK_ROOT (toplevel));
+
+      if (!NAUTILUS_IS_GTK_PLACES_VIEW_ROW (focus_widget))
+        return FALSE;
+
+      if ((state & modifiers) == GDK_SHIFT_MASK)
+        view->current_open_flags = NAUTILUS_GTK_PLACES_OPEN_NEW_TAB;
+      else if ((state & modifiers) == GDK_CONTROL_MASK)
+        view->current_open_flags = NAUTILUS_GTK_PLACES_OPEN_NEW_WINDOW;
+
+      activate_row (view, NAUTILUS_GTK_PLACES_VIEW_ROW (focus_widget), view->current_open_flags);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static void
+on_middle_click_row_event (GtkGestureClick *gesture,
+                           guint            n_press,
+                           double           x,
+                           double           y,
+                           NautilusGtkPlacesView   *view)
+{
+  GtkListBoxRow *row;
+
+  if (n_press != 1)
+    return;
+
+  row = gtk_list_box_get_row_at_y (GTK_LIST_BOX (view->listbox), y);
+  if (row != NULL && gtk_widget_is_sensitive (GTK_WIDGET (row)))
+    activate_row (view, NAUTILUS_GTK_PLACES_VIEW_ROW (row), NAUTILUS_GTK_PLACES_OPEN_NEW_TAB);
+}
+
+
+static void
+on_eject_button_clicked (GtkWidget        *widget,
+                         NautilusGtkPlacesViewRow *row)
+{
+  if (row)
+    {
+      GtkWidget *view = gtk_widget_get_ancestor (GTK_WIDGET (row), NAUTILUS_TYPE_GTK_PLACES_VIEW);
+
+      unmount_mount (NAUTILUS_GTK_PLACES_VIEW (view), nautilus_gtk_places_view_row_get_mount (row));
+    }
+}
+
+static void
+on_connect_button_clicked (NautilusGtkPlacesView *view)
+{
+  const char *uri;
+  GFile *file;
+
+  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 (view->connect_button))
+    return;
+
+  uri = gtk_editable_get_text (GTK_EDITABLE (view->address_entry));
+
+  if (uri != NULL && uri[0] != '\0')
+    file = g_file_new_for_commandline_arg (uri);
+
+  if (file)
+    {
+      view->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 (NautilusGtkPlacesView *view)
+{
+  const char * const *supported_protocols;
+  char *address, *scheme;
+  gboolean supported;
+
+  supported = FALSE;
+  supported_protocols = g_vfs_get_supported_uri_schemes (g_vfs_get_default ());
+  address = g_strdup (gtk_editable_get_text (GTK_EDITABLE (view->address_entry)));
+  scheme = g_uri_parse_scheme (address);
+
+  if (!supported_protocols)
+    goto out;
+
+  if (!scheme)
+    goto out;
+
+  supported = g_strv_contains (supported_protocols, scheme) &&
+              !g_strv_contains (unsupported_protocols, scheme);
+
+out:
+  gtk_widget_set_sensitive (view->connect_button, supported);
+  if (scheme && !supported)
+    gtk_widget_add_css_class (view->address_entry, "error");
+  else
+    gtk_widget_remove_css_class (view->address_entry, "error");
+
+  g_free (address);
+  g_free (scheme);
+}
+
+static void
+on_address_entry_show_help_pressed (NautilusGtkPlacesView        *view,
+                                    GtkEntryIconPosition  icon_pos,
+                                    GtkEntry             *entry)
+{
+  GdkRectangle rect;
+  double x, y;
+
+  /* Setup the auxiliary popover's rectangle */
+  gtk_entry_get_icon_area (GTK_ENTRY (view->address_entry),
+                           GTK_ENTRY_ICON_SECONDARY,
+                           &rect);
+  gtk_widget_translate_coordinates (view->address_entry, GTK_WIDGET (view),
+                                    rect.x, rect.y, &x, &y);
+
+  rect.x = x;
+  rect.y = y;
+  gtk_popover_set_pointing_to (GTK_POPOVER (view->server_adresses_popover), &rect);
+  gtk_widget_set_visible (view->server_adresses_popover, TRUE);
+}
+
+static void
+on_recent_servers_listbox_row_activated (NautilusGtkPlacesView    *view,
+                                         NautilusGtkPlacesViewRow *row,
+                                         GtkWidget        *listbox)
+{
+  char *uri;
+
+  uri = g_object_get_data (G_OBJECT (row), "uri");
+
+  gtk_editable_set_text (GTK_EDITABLE (view->address_entry), uri);
+
+  gtk_widget_hide (view->recent_servers_popover);
+}
+
+static void
+on_listbox_row_activated (NautilusGtkPlacesView    *view,
+                          NautilusGtkPlacesViewRow *row,
+                          GtkWidget        *listbox)
+{
+  activate_row (view, row, view->current_open_flags);
+}
+
+static gboolean
+listbox_filter_func (GtkListBoxRow *row,
+                     gpointer       user_data)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (user_data);
+  gboolean is_placeholder;
+  gboolean retval;
+  gboolean searching;
+  char *name;
+  char *path;
+
+  retval = FALSE;
+  searching = view->search_query && view->search_query[0] != '\0';
+
+  is_placeholder = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "is-placeholder"));
+
+  if (is_placeholder && searching)
+    return FALSE;
+
+  if (!searching)
+    return TRUE;
+
+  g_object_get (row,
+                "name", &name,
+                "path", &path,
+                NULL);
+
+  if (name)
+    {
+      char *lowercase_name = g_utf8_strdown (name, -1);
+
+      retval |= strstr (lowercase_name, view->search_query) != NULL;
+
+      g_free (lowercase_name);
+    }
+
+  if (path)
+    {
+      char *lowercase_path = g_utf8_strdown (path, -1);
+
+      retval |= strstr (lowercase_path, view->search_query) != NULL;
+
+      g_free (lowercase_path);
+    }
+
+  g_free (name);
+  g_free (path);
+
+  return retval;
+}
+
+static void
+listbox_header_func (GtkListBoxRow *row,
+                     GtkListBoxRow *before,
+                     gpointer       user_data)
+{
+  gboolean row_is_network;
+  char *text;
+
+  text = NULL;
+  row_is_network = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "is-network"));
+
+  if (!before)
+    {
+      text = g_strdup_printf ("<b>%s</b>", row_is_network ? _("Networks") : _("On This Computer"));
+    }
+  else
+    {
+      gboolean before_is_network;
+
+      before_is_network = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (before), "is-network"));
+
+      if (before_is_network != row_is_network)
+        text = g_strdup_printf ("<b>%s</b>", row_is_network ? _("Networks") : _("On This Computer"));
+    }
+
+  if (text)
+    {
+      GtkWidget *header;
+      GtkWidget *label;
+      GtkWidget *separator;
+
+      header = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+      gtk_widget_set_margin_top (header, 6);
+
+      separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
+
+      label = g_object_new (GTK_TYPE_LABEL,
+                            "use_markup", TRUE,
+                            "margin-start", 12,
+                            "label", text,
+                            "xalign", 0.0f,
+                            NULL);
+      if (row_is_network)
+        {
+          GtkWidget *header_name;
+          GtkWidget *network_header_spinner;
+
+          gtk_widget_set_margin_end (label, 6);
+
+          header_name = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+          network_header_spinner = gtk_spinner_new ();
+          gtk_widget_set_margin_end (network_header_spinner, 12);
+          g_object_bind_property (NAUTILUS_GTK_PLACES_VIEW (user_data),
+                                  "fetching-networks",
+                                  network_header_spinner,
+                                  "spinning",
+                                  G_BINDING_SYNC_CREATE);
+
+          gtk_box_append (GTK_BOX (header_name), label);
+          gtk_box_append (GTK_BOX (header_name), network_header_spinner);
+          gtk_box_append (GTK_BOX (header), header_name);
+        }
+      else
+        {
+          gtk_widget_set_hexpand (label, TRUE);
+          gtk_widget_set_margin_end (label, 12);
+          gtk_box_append (GTK_BOX (header), label);
+        }
+
+      gtk_box_append (GTK_BOX (header), separator);
+
+      gtk_list_box_row_set_header (row, header);
+
+      g_free (text);
+    }
+  else
+    {
+      gtk_list_box_row_set_header (row, NULL);
+    }
+}
+
+static int
+listbox_sort_func (GtkListBoxRow *row1,
+                   GtkListBoxRow *row2,
+                   gpointer       user_data)
+{
+  gboolean row1_is_network;
+  gboolean row2_is_network;
+  char *path1;
+  char *path2;
+  gboolean *is_placeholder1;
+  gboolean *is_placeholder2;
+  int retval;
+
+  row1_is_network = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row1), "is-network"));
+  row2_is_network = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row2), "is-network"));
+
+  retval = row1_is_network - row2_is_network;
+
+  if (retval != 0)
+    return retval;
+
+  is_placeholder1 = g_object_get_data (G_OBJECT (row1), "is-placeholder");
+  is_placeholder2 = g_object_get_data (G_OBJECT (row2), "is-placeholder");
+
+  /* we can't have two placeholders for the same section */
+  g_assert (!(is_placeholder1 != NULL && is_placeholder2 != NULL));
+
+  if (is_placeholder1)
+    return -1;
+  if (is_placeholder2)
+    return 1;
+
+  g_object_get (row1, "path", &path1, NULL);
+  g_object_get (row2, "path", &path2, NULL);
+
+  retval = g_utf8_collate (path1, path2);
+
+  g_free (path1);
+  g_free (path2);
+
+  return retval;
+}
+
+static void
+nautilus_gtk_places_view_constructed (GObject *object)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (object);
+
+  G_OBJECT_CLASS (nautilus_gtk_places_view_parent_class)->constructed (object);
+
+  gtk_list_box_set_sort_func (GTK_LIST_BOX (view->listbox),
+                              listbox_sort_func,
+                              object,
+                              NULL);
+  gtk_list_box_set_filter_func (GTK_LIST_BOX (view->listbox),
+                                listbox_filter_func,
+                                object,
+                                NULL);
+  gtk_list_box_set_header_func (GTK_LIST_BOX (view->listbox),
+                                listbox_header_func,
+                                object,
+                                NULL);
+
+  /* load drives */
+  update_places (view);
+
+  g_signal_connect_swapped (view->volume_monitor,
+                            "mount-added",
+                            G_CALLBACK (update_places),
+                            object);
+  g_signal_connect_swapped (view->volume_monitor,
+                            "mount-changed",
+                            G_CALLBACK (update_places),
+                            object);
+  g_signal_connect_swapped (view->volume_monitor,
+                            "mount-removed",
+                            G_CALLBACK (update_places),
+                            object);
+  g_signal_connect_swapped (view->volume_monitor,
+                            "volume-added",
+                            G_CALLBACK (update_places),
+                            object);
+  g_signal_connect_swapped (view->volume_monitor,
+                            "volume-changed",
+                            G_CALLBACK (update_places),
+                            object);
+  g_signal_connect_swapped (view->volume_monitor,
+                            "volume-removed",
+                            G_CALLBACK (update_places),
+                            object);
+}
+
+static void
+nautilus_gtk_places_view_map (GtkWidget *widget)
+{
+  NautilusGtkPlacesView *view = NAUTILUS_GTK_PLACES_VIEW (widget);
+
+  gtk_editable_set_text (GTK_EDITABLE (view->address_entry), "");
+
+  GTK_WIDGET_CLASS (nautilus_gtk_places_view_parent_class)->map (widget);
+}
+
+static void
+nautilus_gtk_places_view_class_init (NautilusGtkPlacesViewClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->finalize = nautilus_gtk_places_view_finalize;
+  object_class->dispose = nautilus_gtk_places_view_dispose;
+  object_class->constructed = nautilus_gtk_places_view_constructed;
+  object_class->get_property = nautilus_gtk_places_view_get_property;
+  object_class->set_property = nautilus_gtk_places_view_set_property;
+
+  widget_class->map = nautilus_gtk_places_view_map;
+
+  /*
+   * NautilusGtkPlacesView::open-location:
+   * @view: the object which received the signal.
+   * @location: (type Gio.File): GFile to which the caller should switch.
+   * @open_flags: a single value from NautilusGtkPlacesOpenFlags specifying how the @location
+   * should be opened.
+   *
+   * 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.
+   */
+  places_view_signals [OPEN_LOCATION] =
+          g_signal_new ("open-location",
+                        G_OBJECT_CLASS_TYPE (object_class),
+                        G_SIGNAL_RUN_FIRST,
+                        G_STRUCT_OFFSET (NautilusGtkPlacesViewClass, open_location),
+                        NULL, NULL,
+                        NULL,
+                        G_TYPE_NONE, 2,
+                        G_TYPE_OBJECT,
+                        NAUTILUS_TYPE_OPEN_FLAGS);
+
+  /*
+   * NautilusGtkPlacesView::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.
+   */
+  places_view_signals [SHOW_ERROR_MESSAGE] =
+          g_signal_new ("show-error-message",
+                        G_OBJECT_CLASS_TYPE (object_class),
+                        G_SIGNAL_RUN_FIRST,
+                        G_STRUCT_OFFSET (NautilusGtkPlacesViewClass, show_error_message),
+                        NULL, NULL,
+                        NULL,
+                        G_TYPE_NONE, 2,
+                        G_TYPE_STRING,
+                        G_TYPE_STRING);
+
+  properties[PROP_LOADING] =
+          g_param_spec_boolean ("loading",
+                                "Loading",
+                                "Whether the view is loading locations",
+                                FALSE,
+                                G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);
+
+  properties[PROP_FETCHING_NETWORKS] =
+          g_param_spec_boolean ("fetching-networks",
+                                "Fetching networks",
+                                "Whether the view is fetching networks",
+                                FALSE,
+                                G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);
+
+  properties[PROP_OPEN_FLAGS] =
+          g_param_spec_flags ("open-flags",
+                              "Open Flags",
+                              "Modes in which the calling application can open locations selected in the sidebar",
+                              NAUTILUS_TYPE_OPEN_FLAGS,
+                              NAUTILUS_GTK_PLACES_OPEN_NORMAL,
+                              G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);
+
+  g_object_class_install_properties (object_class, LAST_PROP, properties);
+
+  /* Bind class to template */
+  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/nautilus/gtk/ui/nautilusgtkplacesview.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, actionbar);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, address_entry);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, address_entry_completion);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, completion_store);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, connect_button);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, listbox);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, recent_servers_listbox);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, recent_servers_popover);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, recent_servers_stack);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, stack);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, server_adresses_popover);
+  gtk_widget_class_bind_template_child (widget_class, NautilusGtkPlacesView, available_protocols_grid);
+
+  gtk_widget_class_bind_template_callback (widget_class, on_address_entry_text_changed);
+  gtk_widget_class_bind_template_callback (widget_class, on_address_entry_show_help_pressed);
+  gtk_widget_class_bind_template_callback (widget_class, on_connect_button_clicked);
+  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);
+
+  /**
+   * NautilusGtkPlacesView|location.open:
+   *
+   * Opens the location in the current window.
+   */
+  gtk_widget_class_install_action (widget_class, "location.open", NULL, open_cb);
+
+  /**
+   * NautilusGtkPlacesView|location.open-tab:
+   *
+   * Opens the location in a new tab.
+   */
+  gtk_widget_class_install_action (widget_class, "location.open-tab", NULL, open_cb);
+
+  /**
+   * NautilusGtkPlacesView|location.open-window:
+   *
+   * Opens the location in a new window.
+   */
+  gtk_widget_class_install_action (widget_class, "location.open-window", NULL, open_cb);
+
+  /**
+   * NautilusGtkPlacesView|location.mount:
+   *
+   * Mount the location.
+   */
+  gtk_widget_class_install_action (widget_class, "location.mount", NULL, mount_cb);
+
+  /**
+   * NautilusGtkPlacesView|location.connect:
+   *
+   * Connect the location.
+   */
+  gtk_widget_class_install_action (widget_class, "location.connect", NULL, mount_cb);
+
+  /**
+   * NautilusGtkPlacesView|location.unmount:
+   *
+   * Unmount the location.
+   */
+  gtk_widget_class_install_action (widget_class, "location.unmount", NULL, unmount_cb);
+
+  /**
+   * NautilusGtkPlacesView|location.disconnect:
+   *
+   * Disconnect the location.
+   */
+  gtk_widget_class_install_action (widget_class, "location.disconnect", NULL, unmount_cb);
+
+  /**
+   * NautilusGtkPlacesView|location.properties:
+   *
+   * Show location properties.
+   */
+  gtk_widget_class_install_action (widget_class, "location.properties", NULL, properties_cb);
+
+  gtk_widget_class_set_css_name (widget_class, "placesview");
+  gtk_widget_class_set_accessible_role (widget_class, GTK_ACCESSIBLE_ROLE_LIST);
+}
+
+static void
+nautilus_gtk_places_view_init (NautilusGtkPlacesView *self)
+{
+  GtkEventController *controller;
+
+  self->volume_monitor = g_volume_monitor_get ();
+  self->open_flags = NAUTILUS_GTK_PLACES_OPEN_NORMAL;
+  self->path_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+  self->space_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+  gtk_widget_action_set_enabled (GTK_WIDGET (self), "location.open-tab", FALSE);
+  gtk_widget_action_set_enabled (GTK_WIDGET (self), "location.open-window", FALSE);
+
+  gtk_widget_init_template (GTK_WIDGET (self));
+
+  gtk_widget_set_parent (self->server_adresses_popover, GTK_WIDGET (self));
+  controller = gtk_event_controller_key_new ();
+  g_signal_connect (controller, "key-pressed", G_CALLBACK (on_key_press_event), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+  /* We need an additional controller because GtkListBox only
+   * activates rows for GDK_BUTTON_PRIMARY clicks
+   */
+  controller = (GtkEventController *) gtk_gesture_click_new ();
+  gtk_event_controller_set_propagation_phase (controller, GTK_PHASE_BUBBLE);
+  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (controller), GDK_BUTTON_MIDDLE);
+  g_signal_connect (controller, "released",
+                    G_CALLBACK (on_middle_click_row_event), self);
+  gtk_widget_add_controller (self->listbox, controller);
+
+  populate_available_protocols_grid (GTK_GRID (self->available_protocols_grid));
+}
+
+/*
+ * nautilus_gtk_places_view_new:
+ *
+ * Creates a new NautilusGtkPlacesView widget.
+ *
+ * The application should connect to at least the
+ * NautilusGtkPlacesView::open-location signal to be notified
+ * when the user makes a selection in the view.
+ *
+ * Returns: a newly created NautilusGtkPlacesView
+ */
+GtkWidget *
+nautilus_gtk_places_view_new (void)
+{
+  return g_object_new (NAUTILUS_TYPE_GTK_PLACES_VIEW, NULL);
+}
+
+/*
+ * nautilus_gtk_places_view_set_open_flags:
+ * @view: a NautilusGtkPlacesView
+ * @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 NautilusGtkPlacesView::open-location signal is emitted, its flags
+ * argument will be set to one of the @flags that was passed in
+ * nautilus_gtk_places_view_set_open_flags().
+ *
+ * Passing 0 for @flags will cause NAUTILUS_GTK_PLACES_OPEN_NORMAL to always be sent
+ * to callbacks for the “open-location” signal.
+ */
+void
+nautilus_gtk_places_view_set_open_flags (NautilusGtkPlacesView      *view,
+                                NautilusGtkPlacesOpenFlags  flags)
+{
+  g_return_if_fail (NAUTILUS_IS_GTK_PLACES_VIEW (view));
+
+  if (view->open_flags == flags)
+    return;
+
+  view->open_flags = flags;
+
+  gtk_widget_action_set_enabled (GTK_WIDGET (view), "location.open-tab",
+                                 (flags & NAUTILUS_GTK_PLACES_OPEN_NEW_TAB) != 0);
+  gtk_widget_action_set_enabled (GTK_WIDGET (view), "location.open-window",
+                                 (flags & NAUTILUS_GTK_PLACES_OPEN_NEW_WINDOW) != 0);
+
+  g_object_notify_by_pspec (G_OBJECT (view), properties[PROP_OPEN_FLAGS]);
+}
+
+/*
+ * nautilus_gtk_places_view_get_open_flags:
+ * @view: a NautilusGtkPlacesSidebar
+ *
+ * Gets the open flags.
+ *
+ * Returns: the NautilusGtkPlacesOpenFlags of @view
+ */
+NautilusGtkPlacesOpenFlags
+nautilus_gtk_places_view_get_open_flags (NautilusGtkPlacesView *view)
+{
+  g_return_val_if_fail (NAUTILUS_IS_GTK_PLACES_VIEW (view), 0);
+
+  return view->open_flags;
+}
+
+/*
+ * nautilus_gtk_places_view_get_search_query:
+ * @view: a NautilusGtkPlacesView
+ *
+ * Retrieves the current search query from @view.
+ *
+ * Returns: (transfer none): the current search query.
+ */
+const char *
+nautilus_gtk_places_view_get_search_query (NautilusGtkPlacesView *view)
+{
+  g_return_val_if_fail (NAUTILUS_IS_GTK_PLACES_VIEW (view), NULL);
+
+  return view->search_query;
+}
+
+/*
+ * nautilus_gtk_places_view_set_search_query:
+ * @view: a NautilusGtkPlacesView
+ * @query_text: the query, or NULL.
+ *
+ * Sets the search query of @view. The search is immediately performed
+ * once the query is set.
+ */
+void
+nautilus_gtk_places_view_set_search_query (NautilusGtkPlacesView *view,
+                                  const char    *query_text)
+{
+  g_return_if_fail (NAUTILUS_IS_GTK_PLACES_VIEW (view));
+
+  if (g_strcmp0 (view->search_query, query_text) != 0)
+    {
+      g_clear_pointer (&view->search_query, g_free);
+      view->search_query = g_utf8_strdown (query_text, -1);
+
+      gtk_list_box_invalidate_filter (GTK_LIST_BOX (view->listbox));
+      gtk_list_box_invalidate_headers (GTK_LIST_BOX (view->listbox));
+
+      update_view_mode (view);
+    }
+}
+
+/*
+ * nautilus_gtk_places_view_get_loading:
+ * @view: a NautilusGtkPlacesView
+ *
+ * Returns %TRUE if the view is loading locations.
+ */
+gboolean
+nautilus_gtk_places_view_get_loading (NautilusGtkPlacesView *view)
+{
+  g_return_val_if_fail (NAUTILUS_IS_GTK_PLACES_VIEW (view), FALSE);
+
+  return view->loading;
+}
+
+static void
+update_loading (NautilusGtkPlacesView *view)
+{
+  gboolean loading;
+
+  g_return_if_fail (NAUTILUS_IS_GTK_PLACES_VIEW (view));
+
+  loading = view->fetching_networks || view->connecting_to_server ||
+            view->mounting_volume || view->unmounting_mount;
+
+  set_busy_cursor (view, loading);
+  nautilus_gtk_places_view_set_loading (view, loading);
+}
+
+static void
+nautilus_gtk_places_view_set_loading (NautilusGtkPlacesView *view,
+                             gboolean       loading)
+{
+  g_return_if_fail (NAUTILUS_IS_GTK_PLACES_VIEW (view));
+
+  if (view->loading != loading)
+    {
+      view->loading = loading;
+      g_object_notify_by_pspec (G_OBJECT (view), properties [PROP_LOADING]);
+    }
+}
+
+static gboolean
+nautilus_gtk_places_view_get_fetching_networks (NautilusGtkPlacesView *view)
+{
+  g_return_val_if_fail (NAUTILUS_IS_GTK_PLACES_VIEW (view), FALSE);
+
+  return view->fetching_networks;
+}
+
+static void
+nautilus_gtk_places_view_set_fetching_networks (NautilusGtkPlacesView *view,
+                                       gboolean       fetching_networks)
+{
+  g_return_if_fail (NAUTILUS_IS_GTK_PLACES_VIEW (view));
+
+  if (view->fetching_networks != fetching_networks)
+    {
+      view->fetching_networks = fetching_networks;
+      g_object_notify_by_pspec (G_OBJECT (view), properties [PROP_FETCHING_NETWORKS]);
+    }
+}