Adding upstream version 1:3.38.4.upstream/1%3.38.4upstream

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

1 files changed, 567 insertions, 0 deletions

diff --git a/panels/sharing/cc-sharing-networks.c b/panels/sharing/cc-sharing-networks.c
new file mode 100644
index 0000000..39ebf76
--- /dev/null
+++ b/panels/sharing/cc-sharing-networks.c
@@ -0,0 +1,567 @@
+/*
+ * Copyright (C) 2014 Bastien Nocera <hadess@hadess.net>
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#include "config.h"
+
+#include <gtk/gtk.h>
+#include <gio/gio.h>
+#include <glib/gi18n.h>
+
+#include "cc-sharing-networks.h"
+#include "org.gnome.SettingsDaemon.Sharing.h"
+#include "gsd-sharing-enums.h"
+#include "list-box-helper.h"
+
+struct _CcSharingNetworks {
+  GtkGrid parent_instance;
+
+  GtkWidget *listbox;
+
+  GtkWidget *current_row;
+  GtkWidget *current_label;
+  GtkWidget *current_icon;
+  GtkWidget *current_switch;
+
+  GtkWidget *no_network_row;
+
+  char *service_name;
+  GsdSharing *proxy;
+  CcSharingStatus status;
+
+  GList *networks; /* list of CcSharingNetwork */
+};
+
+
+G_DEFINE_TYPE (CcSharingNetworks, cc_sharing_networks, GTK_TYPE_GRID)
+
+enum {
+  PROP_0,
+  PROP_PROXY,
+  PROP_SERVICE_NAME,
+  PROP_STATUS
+};
+
+static void     cc_sharing_networks_class_init     (CcSharingNetworksClass *klass);
+static void     cc_sharing_networks_init           (CcSharingNetworks      *self);
+static void     cc_sharing_networks_finalize       (GObject                *object);
+
+static void     cc_sharing_update_networks_box     (CcSharingNetworks *self);
+
+typedef struct {
+  char *uuid;
+  char *network_name;
+  char *carrier_type;
+} CcSharingNetwork;
+
+static void
+cc_sharing_network_free (gpointer data)
+{
+  CcSharingNetwork *net = data;
+
+  g_free (net->uuid);
+  g_free (net->network_name);
+  g_free (net->carrier_type);
+  g_free (net);
+}
+
+static void
+cc_sharing_networks_update_status (CcSharingNetworks *self)
+{
+  CcSharingStatus status;
+
+  if (self->networks == NULL)
+    status = CC_SHARING_STATUS_OFF;
+  else if (gtk_widget_is_visible (self->current_switch) &&
+	   gtk_switch_get_active (GTK_SWITCH (self->current_switch)))
+    status = CC_SHARING_STATUS_ACTIVE;
+  else
+    status = CC_SHARING_STATUS_ENABLED;
+
+  if (status != self->status) {
+    self->status = status;
+    g_object_notify (G_OBJECT (self), "status");
+  }
+}
+
+static void
+cc_sharing_update_networks (CcSharingNetworks *self)
+{
+  g_autoptr(GVariant) networks = NULL;
+  char *uuid, *network_name, *carrier_type;
+  GVariantIter iter;
+  g_autoptr(GError) error = NULL;
+
+  g_list_free_full (self->networks, cc_sharing_network_free);
+  self->networks = NULL;
+
+  if (!gsd_sharing_call_list_networks_sync (self->proxy, self->service_name, &networks, NULL, &error)) {
+    g_warning ("couldn't list networks: %s", error->message);
+    g_dbus_proxy_set_cached_property (G_DBUS_PROXY (self->proxy),
+				      "SharingStatus",
+				      g_variant_new_uint32 (GSD_SHARING_STATUS_OFFLINE));
+    cc_list_box_adjust_scrolling (GTK_LIST_BOX (self->listbox));
+    return;
+  }
+
+  g_variant_iter_init (&iter, networks);
+  while (g_variant_iter_next (&iter, "(sss)", &uuid, &network_name, &carrier_type)) {
+    CcSharingNetwork *net;
+
+    net = g_new0 (CcSharingNetwork, 1);
+    net->uuid = uuid;
+    net->network_name = network_name;
+    net->carrier_type = carrier_type;
+    self->networks = g_list_prepend (self->networks, net);
+  }
+  self->networks = g_list_reverse (self->networks);
+  cc_list_box_adjust_scrolling (GTK_LIST_BOX (self->listbox));
+}
+
+static void
+cc_sharing_networks_remove_network (CcSharingNetworks *self,
+                                    GtkWidget         *button)
+{
+  GtkWidget *row;
+  g_autoptr(GError) error = NULL;
+  gboolean ret;
+  const char *uuid;
+
+  row = g_object_get_data (G_OBJECT (button), "row");
+  uuid = g_object_get_data (G_OBJECT (row), "uuid");
+
+  ret = gsd_sharing_call_disable_service_sync (self->proxy,
+					       self->service_name,
+					       uuid,
+					       NULL,
+					       &error);
+  if (!ret)
+    g_warning ("Failed to remove service %s: %s",
+	       self->service_name, error->message);
+
+  cc_sharing_update_networks (self);
+  cc_sharing_update_networks_box (self);
+}
+
+static gboolean
+cc_sharing_networks_enable_network (CcSharingNetworks *self,
+				    gboolean   state,
+                                    GtkSwitch *widget)
+{
+  g_autoptr(GError) error = NULL;
+  gboolean ret;
+
+  if (state) {
+    ret = gsd_sharing_call_enable_service_sync (self->proxy,
+						self->service_name,
+						NULL,
+						&error);
+  } else {
+    ret = gsd_sharing_call_disable_service_sync (self->proxy,
+						 self->service_name,
+						 gsd_sharing_get_current_network (self->proxy),
+						 NULL,
+						 &error);
+  }
+
+  if (ret) {
+    gtk_switch_set_state (widget, state);
+  } else {
+    g_warning ("Failed to %s service %s: %s", state ? "enable" : "disable",
+	       self->service_name, error->message);
+    g_signal_handlers_block_by_func (widget,
+                                     cc_sharing_networks_enable_network, self);
+    gtk_switch_set_active (widget, !state);
+    g_signal_handlers_unblock_by_func (widget,
+                                       cc_sharing_networks_enable_network, self);
+  }
+
+  cc_sharing_update_networks (self);
+  cc_sharing_networks_update_status (self);
+
+  return TRUE;
+}
+
+static GtkWidget *
+cc_sharing_networks_new_row (const char        *uuid,
+			     const char        *network_name,
+			     const char        *carrier_type,
+			     CcSharingNetworks *self)
+{
+  GtkWidget *row, *box, *w;
+  const char *icon_name;
+
+  row = gtk_list_box_row_new ();
+  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  gtk_widget_show (box);
+  gtk_container_set_border_width (GTK_CONTAINER (box), 3);
+  gtk_widget_set_margin_start (box, 6);
+  gtk_container_add (GTK_CONTAINER (row), box);
+
+  if (g_strcmp0 (carrier_type, "802-11-wireless") == 0) {
+    icon_name = "network-wireless-offline-symbolic";
+  } else if (g_strcmp0 (carrier_type, "802-3-ethernet") == 0) {
+    icon_name = "network-wired-disconnected-symbolic";
+  } else {
+    icon_name = "network-wired-symbolic";
+  }
+
+  w = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
+  gtk_widget_show (w);
+  gtk_widget_set_margin_end (w, 12);
+  gtk_container_add (GTK_CONTAINER (box), w);
+
+  /* Label */
+  w = gtk_label_new (network_name);
+  gtk_widget_show (w);
+  gtk_widget_set_margin_end (w, 12);
+  gtk_container_add (GTK_CONTAINER (box), w);
+
+  /* Remove button */
+  w = gtk_button_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
+  gtk_widget_show (w);
+  gtk_button_set_relief (GTK_BUTTON (w), GTK_RELIEF_NONE);
+  gtk_widget_set_margin_top (w, 3);
+  gtk_widget_set_margin_bottom (w, 3);
+  gtk_widget_set_margin_end (w, 12);
+  gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
+  gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0);
+  g_signal_connect_object (G_OBJECT (w), "clicked",
+                           G_CALLBACK (cc_sharing_networks_remove_network), self, G_CONNECT_SWAPPED);
+  g_object_set_data (G_OBJECT (w), "row", row);
+
+  g_object_set_data_full (G_OBJECT (row), "uuid", g_strdup (uuid), g_free);
+
+  return row;
+}
+
+static GtkWidget *
+cc_sharing_networks_new_current_row (CcSharingNetworks *self)
+{
+  GtkWidget *row, *box, *w;
+
+  row = gtk_list_box_row_new ();
+  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  gtk_widget_show (box);
+  gtk_container_set_border_width (GTK_CONTAINER (box), 3);
+  gtk_widget_set_margin_start (box, 6);
+  gtk_container_add (GTK_CONTAINER (row), box);
+
+  /* Icon */
+  w = gtk_image_new_from_icon_name ("image-missing", GTK_ICON_SIZE_MENU);
+  gtk_widget_show (w);
+  gtk_widget_set_margin_end (w, 12);
+  gtk_container_add (GTK_CONTAINER (box), w);
+  self->current_icon = w;
+
+  /* Label */
+  w = gtk_label_new ("");
+  gtk_widget_show (w);
+  gtk_container_add (GTK_CONTAINER (box), w);
+  gtk_widget_set_margin_end (w, 12);
+  self->current_label = w;
+
+  w = gtk_switch_new ();
+  gtk_widget_show (w);
+  gtk_widget_set_margin_top (w, 3);
+  gtk_widget_set_margin_bottom (w, 3);
+  gtk_widget_set_margin_end (w, 12);
+  gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
+  gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0);
+  g_signal_connect_object (G_OBJECT (w), "state-set",
+                           G_CALLBACK (cc_sharing_networks_enable_network), self, G_CONNECT_SWAPPED);
+  self->current_switch = w;
+  g_object_set_data (G_OBJECT (w), "row", row);
+
+  return row;
+}
+
+static GtkWidget *
+cc_sharing_networks_new_no_network_row (CcSharingNetworks *self)
+{
+  GtkWidget *row, *box, *w;
+
+  row = gtk_list_box_row_new ();
+  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  gtk_widget_show (box);
+  gtk_container_set_border_width (GTK_CONTAINER (box), 12);
+  gtk_container_add (GTK_CONTAINER (row), box);
+
+  /* Label */
+  w = gtk_label_new (_("No networks selected for sharing"));
+  gtk_widget_show (w);
+  gtk_widget_set_hexpand (w, TRUE);
+  gtk_widget_set_halign (w, GTK_ALIGN_CENTER);
+  gtk_style_context_add_class (gtk_widget_get_style_context (w), "dim-label");
+  gtk_container_add (GTK_CONTAINER (box), w);
+
+  return row;
+}
+
+static void
+cc_sharing_update_networks_box (CcSharingNetworks *self)
+{
+  gboolean current_visible;
+  const char *current_network;
+  g_autoptr(GList) children = NULL;
+  GList *l;
+
+  children = gtk_container_get_children (GTK_CONTAINER (self->listbox));
+  for (l = children; l != NULL; l = l->next) {
+    GtkWidget *row = l->data;
+
+    if (row != self->current_row &&
+	row != self->no_network_row)
+      gtk_widget_destroy (row);
+  }
+
+  current_network = gsd_sharing_get_current_network (self->proxy);
+
+  if (current_network != NULL &&
+      !g_str_equal (current_network, "")) {
+    gboolean available;
+    const char *carrier_type, *icon_name, *current_network_name;
+
+    gtk_widget_show (self->current_row);
+    current_visible = TRUE;
+
+    /* Network name */
+    g_object_set_data_full (G_OBJECT (self->current_row),
+			    "uuid", g_strdup (current_network), g_free);
+    current_network_name = gsd_sharing_get_current_network_name (self->proxy);
+    gtk_label_set_label (GTK_LABEL (self->current_label), current_network_name);
+
+    /* Icon */
+    carrier_type = gsd_sharing_get_carrier_type (self->proxy);
+    if (g_strcmp0 (carrier_type, "802-11-wireless") == 0) {
+      icon_name = "network-wireless-signal-excellent-symbolic";
+    } else if (g_strcmp0 (carrier_type, "802-3-ethernet") == 0) {
+      icon_name = "network-wired-symbolic";
+    } else {
+      icon_name = "network-wired-symbolic";
+    }
+    gtk_image_set_from_icon_name (GTK_IMAGE (self->current_icon), icon_name, GTK_ICON_SIZE_SMALL_TOOLBAR);
+
+    /* State */
+    available = gsd_sharing_get_sharing_status (self->proxy) == GSD_SHARING_STATUS_AVAILABLE;
+    gtk_widget_set_sensitive (self->current_switch, available);
+    //FIXME add a subtitle explaining why it's disabled
+  } else {
+    gtk_widget_hide (self->current_row);
+    current_visible = FALSE;
+  }
+
+  for (l = self->networks; l != NULL; l = l->next) {
+    CcSharingNetwork *net = l->data;
+    GtkWidget *row;
+
+    if (g_strcmp0 (net->uuid, current_network) == 0) {
+      g_signal_handlers_block_by_func (self->current_switch,
+				       cc_sharing_networks_enable_network, self);
+      gtk_switch_set_state (GTK_SWITCH (self->current_switch), TRUE);
+      g_signal_handlers_unblock_by_func (self->current_switch,
+					 cc_sharing_networks_enable_network, self);
+      continue;
+    }
+
+    row = cc_sharing_networks_new_row (net->uuid,
+				       net->network_name,
+				       net->carrier_type,
+				       self);
+    gtk_widget_show (row);
+    gtk_list_box_insert (GTK_LIST_BOX (self->listbox), row, -1);
+  }
+
+  if (self->networks == NULL &&
+      !current_visible) {
+    gtk_widget_show (self->no_network_row);
+  } else {
+    gtk_widget_hide (self->no_network_row);
+  }
+
+  cc_sharing_networks_update_status (self);
+
+  cc_list_box_adjust_scrolling (GTK_LIST_BOX (self->listbox));
+}
+
+static void
+current_network_changed (CcSharingNetworks *self)
+{
+  cc_sharing_update_networks (self);
+  cc_sharing_update_networks_box (self);
+}
+
+static void
+cc_sharing_networks_constructed (GObject *object)
+{
+  CcSharingNetworks *self;
+
+  G_OBJECT_CLASS (cc_sharing_networks_parent_class)->constructed (object);
+
+  self = CC_SHARING_NETWORKS (object);
+
+  gtk_list_box_set_header_func (GTK_LIST_BOX (self->listbox),
+				cc_list_box_update_header_func, NULL,
+				NULL);
+
+  cc_list_box_setup_scrolling (GTK_LIST_BOX (self->listbox), 3);
+
+  self->current_row = cc_sharing_networks_new_current_row (self);
+  gtk_list_box_insert (GTK_LIST_BOX (self->listbox), self->current_row, -1);
+  g_object_set_data (G_OBJECT (self), "switch", self->current_switch);
+
+  self->no_network_row = cc_sharing_networks_new_no_network_row (self);
+  gtk_list_box_insert (GTK_LIST_BOX (self->listbox), self->no_network_row, -1);
+
+  cc_sharing_update_networks (self);
+  cc_sharing_update_networks_box (self);
+
+  g_signal_connect_object (self->proxy, "notify::current-network",
+                           G_CALLBACK (current_network_changed), self, G_CONNECT_SWAPPED);
+}
+
+static void
+cc_sharing_networks_init (CcSharingNetworks *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+}
+
+GtkWidget *
+cc_sharing_networks_new (GDBusProxy *proxy,
+			 const char *service_name)
+{
+  g_return_val_if_fail (GSD_IS_SHARING (proxy), NULL);
+  g_return_val_if_fail (service_name != NULL, NULL);
+
+  return GTK_WIDGET (g_object_new (CC_TYPE_SHARING_NETWORKS,
+				   "proxy", proxy,
+				   "service-name", service_name,
+				   NULL));
+}
+
+static void
+cc_sharing_networks_set_property (GObject      *object,
+				  guint         prop_id,
+				  const GValue *value,
+				  GParamSpec   *pspec)
+{
+  CcSharingNetworks *self;
+
+  self = CC_SHARING_NETWORKS (object);
+
+  switch (prop_id) {
+  case PROP_SERVICE_NAME:
+    self->service_name = g_value_dup_string (value);
+    break;
+  case PROP_PROXY:
+    self->proxy = g_value_dup_object (value);
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+cc_sharing_networks_get_property (GObject      *object,
+				  guint         prop_id,
+				  GValue       *value,
+				  GParamSpec   *pspec)
+{
+  CcSharingNetworks *self;
+
+  self = CC_SHARING_NETWORKS (object);
+
+  switch (prop_id) {
+  case PROP_STATUS:
+    g_value_set_uint (value, self->status);
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+cc_sharing_networks_finalize (GObject *object)
+{
+  CcSharingNetworks *self;
+
+  g_return_if_fail (object != NULL);
+  g_return_if_fail (CC_IS_SHARING_NETWORKS (object));
+
+  self = CC_SHARING_NETWORKS (object);
+
+  g_return_if_fail (self != NULL);
+
+  g_clear_object (&self->proxy);
+  g_clear_pointer (&self->service_name, g_free);
+
+  if (self->networks != NULL) {
+    g_list_free_full (self->networks, cc_sharing_network_free);
+    self->networks = NULL;
+  }
+
+  G_OBJECT_CLASS (cc_sharing_networks_parent_class)->finalize (object);
+}
+
+
+static void
+cc_sharing_networks_class_init (CcSharingNetworksClass *klass)
+{
+  GObjectClass  *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->set_property = cc_sharing_networks_set_property;
+  object_class->get_property = cc_sharing_networks_get_property;
+  object_class->finalize = cc_sharing_networks_finalize;
+  object_class->constructed = cc_sharing_networks_constructed;
+
+  g_object_class_install_property (object_class,
+                                   PROP_PROXY,
+                                   g_param_spec_object ("proxy",
+                                                        "proxy",
+                                                        "proxy",
+                                                        GSD_TYPE_SHARING_PROXY,
+                                                        G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+
+  g_object_class_install_property (object_class,
+                                   PROP_SERVICE_NAME,
+                                   g_param_spec_string ("service-name",
+                                                        "service-name",
+                                                        "service-name",
+                                                        NULL,
+                                                        G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+
+  g_object_class_install_property (object_class,
+                                   PROP_STATUS,
+                                   g_param_spec_uint ("status",
+                                                      "status",
+                                                      "status",
+                                                      CC_SHARING_STATUS_UNSET, CC_SHARING_STATUS_ACTIVE + 1, CC_SHARING_STATUS_OFF,
+                                                      G_PARAM_READABLE));
+
+  gtk_widget_class_set_template_from_resource (widget_class,
+                                               "/org/gnome/control-center/sharing/cc-sharing-networks.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, CcSharingNetworks, listbox);
+}
+
+/*
+ * vim: sw=2 ts=8 cindent noai bs=2
+ */