summaryrefslogtreecommitdiffstats
path: root/panels/info-overview/cc-info-overview-panel.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:45:20 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:45:20 +0000
commitae1c76ff830d146d41e88d6fba724c0a54bce868 (patch)
tree3c354bec95af07be35fc71a4b738268496f1a1c4 /panels/info-overview/cc-info-overview-panel.c
parentInitial commit. (diff)
downloadgnome-control-center-ae1c76ff830d146d41e88d6fba724c0a54bce868.tar.xz
gnome-control-center-ae1c76ff830d146d41e88d6fba724c0a54bce868.zip
Adding upstream version 1:43.6.upstream/1%43.6upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--panels/info-overview/cc-info-overview-panel.c993
1 files changed, 993 insertions, 0 deletions
diff --git a/panels/info-overview/cc-info-overview-panel.c b/panels/info-overview/cc-info-overview-panel.c
new file mode 100644
index 0000000..1ae5c7a
--- /dev/null
+++ b/panels/info-overview/cc-info-overview-panel.c
@@ -0,0 +1,993 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
+ *
+ * Copyright (C) 2019 Purism SPC
+ * Copyright (C) 2017 Mohammed Sadiq <sadiq@sadiqpk.org>
+ * Copyright (C) 2010 Red Hat, Inc
+ * Copyright (C) 2008 William Jon McCann <jmccann@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <config.h>
+
+#include "cc-hostname-entry.h"
+#include "shell/cc-object-storage.h"
+
+#include "cc-info-overview-resources.h"
+#include "info-cleanup.h"
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+#include <gio/gunixmounts.h>
+#include <gio/gdesktopappinfo.h>
+
+#include <glibtop/fsusage.h>
+#include <glibtop/mountlist.h>
+#include <glibtop/mem.h>
+#include <glibtop/sysinfo.h>
+#include <udisks/udisks.h>
+#include <gudev/gudev.h>
+
+#include <gdk/gdk.h>
+
+#ifdef GDK_WINDOWING_WAYLAND
+#include <gdk/wayland/gdkwayland.h>
+#endif
+#ifdef GDK_WINDOWING_X11
+#include <gdk/x11/gdkx.h>
+#endif
+
+#include "cc-list-row.h"
+#include "cc-info-overview-panel.h"
+
+struct _CcInfoOverviewPanel
+{
+ CcPanel parent_instance;
+
+ GtkEntry *device_name_entry;
+ GtkWidget *rename_button;
+ CcListRow *disk_row;
+ CcListRow *gnome_version_row;
+ CcListRow *graphics_row;
+ CcListRow *hardware_model_row;
+ GtkDialog *hostname_editor;
+ CcHostnameEntry *hostname_entry;
+ CcListRow *hostname_row;
+ CcListRow *memory_row;
+ GtkPicture *os_logo;
+ CcListRow *os_name_row;
+ CcListRow *os_build_row;
+ CcListRow *os_type_row;
+ CcListRow *processor_row;
+ AdwActionRow *software_updates_row;
+ CcListRow *virtualization_row;
+ CcListRow *windowing_system_row;
+};
+
+G_DEFINE_TYPE (CcInfoOverviewPanel, cc_info_overview_panel, CC_TYPE_PANEL)
+
+static char *
+get_renderer_from_session (void)
+{
+ g_autoptr(GDBusProxy) session_proxy = NULL;
+ g_autoptr(GVariant) renderer_variant = NULL;
+ char *renderer;
+ g_autoptr(GError) error = NULL;
+
+ session_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ "org.gnome.SessionManager",
+ "/org/gnome/SessionManager",
+ "org.gnome.SessionManager",
+ NULL, &error);
+ if (error != NULL)
+ {
+ g_warning ("Unable to connect to create a proxy for org.gnome.SessionManager: %s",
+ error->message);
+ return NULL;
+ }
+
+ renderer_variant = g_dbus_proxy_get_cached_property (session_proxy, "Renderer");
+
+ if (!renderer_variant)
+ {
+ g_warning ("Unable to retrieve org.gnome.SessionManager.Renderer property");
+ return NULL;
+ }
+
+ renderer = info_cleanup (g_variant_get_string (renderer_variant, NULL));
+
+ return renderer;
+}
+
+/* @env is an array of strings with each pair of strings being the
+ * key followed by the value */
+static char *
+get_renderer_from_helper (const char **env)
+{
+ int status;
+ char *argv[] = { LIBEXECDIR "/gnome-control-center-print-renderer", NULL };
+ g_auto(GStrv) envp = NULL;
+ g_autofree char *renderer = NULL;
+ g_autoptr(GError) error = NULL;
+
+ g_debug ("About to launch '%s'", argv[0]);
+
+ if (env != NULL)
+ {
+ guint i;
+ g_debug ("With environment:");
+ envp = g_get_environ ();
+ for (i = 0; env != NULL && env[i] != NULL; i = i + 2)
+ {
+ g_debug (" %s = %s", env[i], env[i+1]);
+ envp = g_environ_setenv (envp, env[i], env[i+1], TRUE);
+ }
+ }
+ else
+ {
+ g_debug ("No additional environment variables");
+ }
+
+ if (!g_spawn_sync (NULL, (char **) argv, envp, 0, NULL, NULL, &renderer, NULL, &status, &error))
+ {
+ g_debug ("Failed to get GPU: %s", error->message);
+ return NULL;
+ }
+
+ if (!g_spawn_check_wait_status (status, NULL))
+ return NULL;
+
+ if (renderer == NULL || *renderer == '\0')
+ return NULL;
+
+ return info_cleanup (renderer);
+}
+
+typedef struct {
+ char *name;
+ gboolean is_default;
+} GpuData;
+
+static int
+gpu_data_sort (gconstpointer a, gconstpointer b)
+{
+ GpuData *gpu_a = (GpuData *) a;
+ GpuData *gpu_b = (GpuData *) b;
+
+ if (gpu_a->is_default)
+ return 1;
+ if (gpu_b->is_default)
+ return -1;
+ return 0;
+}
+
+static void
+gpu_data_free (GpuData *data)
+{
+ g_free (data->name);
+ g_free (data);
+}
+
+static char *
+get_renderer_from_switcheroo (void)
+{
+ g_autoptr(GDBusProxy) switcheroo_proxy = NULL;
+ g_autoptr(GVariant) variant = NULL;
+ g_autoptr(GError) error = NULL;
+ GString *renderers_string;
+ guint i, num_children;
+ GSList *renderers, *l;
+
+ switcheroo_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ "net.hadess.SwitcherooControl",
+ "/net/hadess/SwitcherooControl",
+ "net.hadess.SwitcherooControl",
+ NULL, &error);
+ if (switcheroo_proxy == NULL)
+ {
+ g_debug ("Unable to connect to create a proxy for net.hadess.SwitcherooControl: %s",
+ error->message);
+ return NULL;
+ }
+
+ variant = g_dbus_proxy_get_cached_property (switcheroo_proxy, "GPUs");
+
+ if (!variant)
+ {
+ g_debug ("Unable to retrieve net.hadess.SwitcherooControl.GPUs property, the daemon is likely not running");
+ return NULL;
+ }
+
+ renderers_string = g_string_new (NULL);
+ num_children = g_variant_n_children (variant);
+ renderers = NULL;
+ for (i = 0; i < num_children; i++)
+ {
+ g_autoptr(GVariant) gpu;
+ g_autoptr(GVariant) name = NULL;
+ g_autoptr(GVariant) env = NULL;
+ g_autoptr(GVariant) default_variant = NULL;
+ const char *name_s;
+ g_autofree const char **env_s = NULL;
+ gsize env_len;
+ g_autofree char *renderer = NULL;
+ GpuData *gpu_data;
+
+ gpu = g_variant_get_child_value (variant, i);
+ if (!gpu ||
+ !g_variant_is_of_type (gpu, G_VARIANT_TYPE ("a{s*}")))
+ continue;
+
+ name = g_variant_lookup_value (gpu, "Name", NULL);
+ env = g_variant_lookup_value (gpu, "Environment", NULL);
+ if (!name || !env)
+ continue;
+ name_s = g_variant_get_string (name, NULL);
+ g_debug ("Getting renderer from helper for GPU '%s'", name_s);
+ env_s = g_variant_get_strv (env, &env_len);
+ if (env_s != NULL && env_len % 2 != 0)
+ {
+ g_autofree char *debug = NULL;
+ debug = g_strjoinv ("\n", (char **) env_s);
+ g_warning ("Invalid environment returned from switcheroo:\n%s", debug);
+ g_clear_pointer (&env_s, g_free);
+ }
+
+ renderer = get_renderer_from_helper (env_s);
+ default_variant = g_variant_lookup_value (gpu, "Default", NULL);
+
+ /* We could give up if we don't have a renderer, but that
+ * might just mean gnome-session isn't installed. We fall back
+ * to the device name in udev instead, which is better than nothing */
+
+ gpu_data = g_new0 (GpuData, 1);
+ gpu_data->name = g_strdup (renderer ? renderer : name_s);
+ gpu_data->is_default = default_variant ? g_variant_get_boolean (default_variant) : FALSE;
+ renderers = g_slist_prepend (renderers, gpu_data);
+ }
+
+ renderers = g_slist_sort (renderers, gpu_data_sort);
+ for (l = renderers; l != NULL; l = l->next)
+ {
+ GpuData *data = l->data;
+ if (renderers_string->len > 0)
+ g_string_append (renderers_string, " / ");
+ g_string_append (renderers_string, data->name);
+ }
+ g_slist_free_full (renderers, (GDestroyNotify) gpu_data_free);
+
+ if (renderers_string->len == 0)
+ {
+ g_string_free (renderers_string, TRUE);
+ return NULL;
+ }
+
+ return g_string_free (renderers_string, FALSE);
+}
+
+static gchar *
+get_graphics_hardware_string (void)
+{
+ g_autofree char *discrete_renderer = NULL;
+ g_autofree char *renderer = NULL;
+
+ renderer = get_renderer_from_switcheroo ();
+ if (!renderer)
+ renderer = get_renderer_from_session ();
+ if (!renderer)
+ renderer = get_renderer_from_helper (NULL);
+ if (!renderer)
+ return g_strdup (_("Unknown"));
+ return g_strdup (renderer);
+}
+
+static char *
+get_os_name (void)
+{
+ g_autofree gchar *name = NULL;
+ g_autofree gchar *version_id = NULL;
+ g_autofree gchar *pretty_name = NULL;
+
+ name = g_get_os_info (G_OS_INFO_KEY_NAME);
+ version_id = g_get_os_info (G_OS_INFO_KEY_VERSION_ID);
+ pretty_name = g_get_os_info (G_OS_INFO_KEY_PRETTY_NAME);
+
+ if (pretty_name)
+ return g_steal_pointer (&pretty_name);
+ else if (name && version_id)
+ return g_strdup_printf ("%s %s", name, version_id);
+ else
+ return g_strdup (_("Unknown"));
+}
+
+static char *
+get_os_build_id (void)
+{
+ char *build_id = NULL;
+
+ build_id = g_get_os_info ("BUILD_ID");
+
+ return build_id;
+}
+
+static char *
+get_os_type (void)
+{
+ if (GLIB_SIZEOF_VOID_P == 8)
+ /* translators: This is the type of architecture for the OS */
+ return g_strdup_printf (_("64-bit"));
+ else
+ /* translators: This is the type of architecture for the OS */
+ return g_strdup_printf (_("32-bit"));
+}
+
+static void
+get_primary_disc_info (CcInfoOverviewPanel *self)
+{
+ g_autoptr(UDisksClient) client = NULL;
+ GDBusObjectManager *manager;
+ g_autolist(GDBusObject) objects = NULL;
+ GList *l;
+ guint64 total_size;
+ g_autoptr(GError) error = NULL;
+
+ total_size = 0;
+
+ client = udisks_client_new_sync (NULL, &error);
+ if (client == NULL)
+ {
+ g_warning ("Unable to get UDisks client: %s. Disk information will not be available.",
+ error->message);
+ cc_list_row_set_secondary_label (self->disk_row, _("Unknown"));
+ return;
+ }
+
+ manager = udisks_client_get_object_manager (client);
+ objects = g_dbus_object_manager_get_objects (manager);
+
+ for (l = objects; l != NULL; l = l->next)
+ {
+ UDisksDrive *drive;
+ drive = udisks_object_peek_drive (UDISKS_OBJECT (l->data));
+
+ /* Skip removable devices */
+ if (drive == NULL ||
+ udisks_drive_get_removable (drive) ||
+ udisks_drive_get_ejectable (drive))
+ {
+ continue;
+ }
+
+ total_size += udisks_drive_get_size (drive);
+ }
+
+ if (total_size > 0)
+ {
+ g_autofree gchar *size = g_format_size (total_size);
+ cc_list_row_set_secondary_label (self->disk_row, size);
+ }
+ else
+ {
+ cc_list_row_set_secondary_label (self->disk_row, _("Unknown"));
+ }
+}
+
+static void
+get_hardware_model (CcInfoOverviewPanel *self)
+{
+ g_autoptr(GDBusProxy) hostnamed_proxy = NULL;
+ g_autoptr(GVariant) vendor_variant = NULL;
+ g_autoptr(GVariant) model_variant = NULL;
+ const char *vendor_string, *model_string;
+ g_autoptr(GError) error = NULL;
+
+ hostnamed_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ "org.freedesktop.hostname1",
+ "/org/freedesktop/hostname1",
+ "org.freedesktop.hostname1",
+ NULL,
+ &error);
+ if (hostnamed_proxy == NULL)
+ {
+ g_debug ("Couldn't get hostnamed to start, bailing: %s", error->message);
+ return;
+ }
+
+ vendor_variant = g_dbus_proxy_get_cached_property (hostnamed_proxy, "HardwareVendor");
+ if (!vendor_variant)
+ {
+ g_debug ("Unable to retrieve org.freedesktop.hostname1.HardwareVendor property");
+ return;
+ }
+
+ model_variant = g_dbus_proxy_get_cached_property (hostnamed_proxy, "HardwareModel");
+ if (!model_variant)
+ {
+ g_debug ("Unable to retrieve org.freedesktop.hostname1.HardwareModel property");
+ return;
+ }
+
+ vendor_string = g_variant_get_string (vendor_variant, NULL),
+ model_string = g_variant_get_string (model_variant, NULL);
+
+ if (vendor_string && g_strcmp0 (vendor_string, "") != 0)
+ {
+ g_autofree gchar *vendor_model = NULL;
+
+ vendor_model = g_strdup_printf ("%s %s", vendor_string, model_string);
+
+ cc_list_row_set_secondary_label (self->hardware_model_row, vendor_model);
+ gtk_widget_set_visible (GTK_WIDGET (self->hardware_model_row), TRUE);
+ }
+}
+
+static char *
+get_cpu_info (const glibtop_sysinfo *info)
+{
+ g_autoptr(GHashTable) counts = NULL;
+ g_autoptr(GString) cpu = NULL;
+ GHashTableIter iter;
+ gpointer key, value;
+ int i;
+ int j;
+
+ counts = g_hash_table_new (g_str_hash, g_str_equal);
+
+ /* count duplicates */
+ for (i = 0; i != info->ncpu; ++i)
+ {
+ const char * const keys[] = { "model name", "cpu", "Processor" };
+ char *model;
+ int *count;
+
+ model = NULL;
+
+ for (j = 0; model == NULL && j != G_N_ELEMENTS (keys); ++j)
+ {
+ model = g_hash_table_lookup (info->cpuinfo[i].values,
+ keys[j]);
+ }
+
+ if (model == NULL)
+ continue;
+
+ count = g_hash_table_lookup (counts, model);
+ if (count == NULL)
+ g_hash_table_insert (counts, model, GINT_TO_POINTER (1));
+ else
+ g_hash_table_replace (counts, model, GINT_TO_POINTER (GPOINTER_TO_INT (count) + 1));
+ }
+
+ cpu = g_string_new (NULL);
+ g_hash_table_iter_init (&iter, counts);
+ while (g_hash_table_iter_next (&iter, &key, &value))
+ {
+ g_autofree char *cleanedup = NULL;
+ int count;
+
+ count = GPOINTER_TO_INT (value);
+ cleanedup = info_cleanup ((const char *) key);
+ if (cpu->len != 0)
+ g_string_append_printf (cpu, " ");
+ if (count > 1)
+ g_string_append_printf (cpu, "%s \303\227 %d", cleanedup, count);
+ else
+ g_string_append_printf (cpu, "%s", cleanedup);
+ }
+
+ return g_strdup (cpu->str);
+}
+
+static struct {
+ const char *id;
+ const char *display;
+} const virt_tech[] = {
+ { "kvm", "KVM" },
+ { "qemu", "QEmu" },
+ { "vmware", "VMware" },
+ { "microsoft", "Microsoft" },
+ { "oracle", "Oracle" },
+ { "xen", "Xen" },
+ { "bochs", "Bochs" },
+ { "chroot", "chroot" },
+ { "openvz", "OpenVZ" },
+ { "lxc", "LXC" },
+ { "lxc-libvirt", "LXC (libvirt)" },
+ { "systemd-nspawn", "systemd (nspawn)" }
+};
+
+static void
+set_virtualization_label (CcInfoOverviewPanel *self,
+ const char *virt)
+{
+ const char *display_name;
+ guint i;
+
+ if (virt == NULL || *virt == '\0')
+ {
+ gtk_widget_hide (GTK_WIDGET (self->virtualization_row));
+ return;
+ }
+
+ gtk_widget_show (GTK_WIDGET (self->virtualization_row));
+
+ display_name = NULL;
+ for (i = 0; i < G_N_ELEMENTS (virt_tech); i++)
+ {
+ if (g_str_equal (virt_tech[i].id, virt))
+ {
+ display_name = _(virt_tech[i].display);
+ break;
+ }
+ }
+
+ cc_list_row_set_secondary_label (self->virtualization_row, display_name ? display_name : virt);
+}
+
+static void
+info_overview_panel_setup_virt (CcInfoOverviewPanel *self)
+{
+ g_autoptr(GError) error = NULL;
+ g_autoptr(GDBusProxy) systemd_proxy = NULL;
+ g_autoptr(GVariant) variant = NULL;
+ GVariant *inner;
+
+ systemd_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+ G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1",
+ NULL,
+ &error);
+
+ if (systemd_proxy == NULL)
+ {
+ g_debug ("systemd not available, bailing: %s", error->message);
+ set_virtualization_label (self, NULL);
+ return;
+ }
+
+ variant = g_dbus_proxy_call_sync (systemd_proxy,
+ "org.freedesktop.DBus.Properties.Get",
+ g_variant_new ("(ss)", "org.freedesktop.systemd1.Manager", "Virtualization"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+ if (variant == NULL)
+ {
+ g_debug ("Failed to get property '%s': %s", "Virtualization", error->message);
+ set_virtualization_label (self, NULL);
+ return;
+ }
+
+ g_variant_get (variant, "(v)", &inner);
+ set_virtualization_label (self, g_variant_get_string (inner, NULL));
+}
+
+static const char *
+get_windowing_system (void)
+{
+ GdkDisplay *display;
+
+ display = gdk_display_get_default ();
+
+#if defined(GDK_WINDOWING_X11)
+ if (GDK_IS_X11_DISPLAY (display))
+ return _("X11");
+#endif /* GDK_WINDOWING_X11 */
+#if defined(GDK_WINDOWING_WAYLAND)
+ if (GDK_IS_WAYLAND_DISPLAY (display))
+ return _("Wayland");
+#endif /* GDK_WINDOWING_WAYLAND */
+ return C_("Windowing system (Wayland, X11, or Unknown)", "Unknown");
+}
+
+static guint64
+get_ram_size_libgtop (void)
+{
+ glibtop_mem mem;
+
+ glibtop_get_mem (&mem);
+ return mem.total;
+}
+
+static guint64
+get_ram_size_dmi (void)
+{
+ g_autoptr(GUdevClient) client = NULL;
+ g_autoptr(GUdevDevice) dmi = NULL;
+ const gchar * const subsystems[] = {"dmi", NULL };
+ guint64 ram_total = 0;
+ guint64 num_ram;
+ guint i;
+
+ client = g_udev_client_new (subsystems);
+ dmi = g_udev_client_query_by_sysfs_path (client, "/sys/devices/virtual/dmi/id");
+ if (!dmi)
+ return 0;
+ num_ram = g_udev_device_get_property_as_uint64 (dmi, "MEMORY_ARRAY_NUM_DEVICES");
+ for (i = 0; i < num_ram ; i++) {
+ g_autofree char *prop = NULL;
+
+ prop = g_strdup_printf ("MEMORY_DEVICE_%d_SIZE", i);
+ ram_total += g_udev_device_get_property_as_uint64 (dmi, prop);
+ }
+ return ram_total;
+}
+
+static char *
+get_gnome_version (GDBusProxy *proxy)
+{
+ g_autoptr(GVariant) variant = NULL;
+ const char *gnome_version = NULL;
+ if (!proxy)
+ return NULL;
+
+ variant = g_dbus_proxy_get_cached_property (proxy, "ShellVersion");
+ if (!variant)
+ return NULL;
+
+ gnome_version = g_variant_get_string (variant, NULL);
+ if (!gnome_version || *gnome_version == '\0')
+ return NULL;
+ return g_strdup (gnome_version);
+}
+
+static void
+shell_proxy_ready (GObject *source,
+ GAsyncResult *res,
+ CcInfoOverviewPanel *self)
+{
+ g_autoptr(GDBusProxy) proxy = NULL;
+ g_autoptr(GError) error = NULL;
+ g_autoptr(GVariant) variant = NULL;
+ g_autofree char *gnome_version = NULL;
+
+ proxy = cc_object_storage_create_dbus_proxy_finish (res, &error);
+ if (!proxy)
+ {
+ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+ return;
+ g_warning ("Failed to contact gnome-shell: %s", error->message);
+ }
+
+ gnome_version = get_gnome_version (proxy);
+
+ if (!gnome_version)
+ {
+ /* translators: this is the placeholder string when the GNOME Shell
+ * version couldn't be loaded, eg. “GNOME Version: Not Available” */
+ cc_list_row_set_secondary_label (self->gnome_version_row, _("Not Available"));
+ }
+ else
+ {
+ cc_list_row_set_secondary_label (self->gnome_version_row, gnome_version);
+ }
+}
+
+static void
+info_overview_panel_setup_overview (CcInfoOverviewPanel *self)
+{
+ g_autofree gchar *gnome_version = NULL;
+ guint64 ram_size;
+ const glibtop_sysinfo *info;
+ g_autofree char *memory_text = NULL;
+ g_autofree char *cpu_text = NULL;
+ g_autofree char *os_type_text = NULL;
+ g_autofree char *os_name_text = NULL;
+ g_autofree char *os_build_text = NULL;
+ g_autofree gchar *graphics_hardware_string = NULL;
+
+ cc_object_storage_create_dbus_proxy (G_BUS_TYPE_SESSION,
+ G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS |
+ G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+ "org.gnome.Shell",
+ "/org/gnome/Shell",
+ "org.gnome.Shell",
+ cc_panel_get_cancellable (CC_PANEL (self)),
+ (GAsyncReadyCallback) shell_proxy_ready,
+ self);
+
+ get_hardware_model (self);
+
+ ram_size = get_ram_size_dmi ();
+ if (ram_size == 0)
+ ram_size = get_ram_size_libgtop ();
+ memory_text = g_format_size_full (ram_size, G_FORMAT_SIZE_IEC_UNITS);
+ cc_list_row_set_secondary_label (self->memory_row, memory_text);
+
+ info = glibtop_get_sysinfo ();
+
+ cpu_text = get_cpu_info (info);
+ cc_list_row_set_secondary_markup (self->processor_row, cpu_text);
+
+ graphics_hardware_string = get_graphics_hardware_string ();
+ cc_list_row_set_secondary_markup (self->graphics_row, graphics_hardware_string);
+
+ get_primary_disc_info (self);
+
+ os_name_text = get_os_name ();
+ cc_list_row_set_secondary_label (self->os_name_row, os_name_text);
+
+ os_build_text = get_os_build_id ();
+ cc_list_row_set_secondary_label (self->os_build_row, os_build_text);
+ gtk_widget_set_visible (GTK_WIDGET (self->os_build_row), os_build_text != NULL);
+
+ os_type_text = get_os_type ();
+ cc_list_row_set_secondary_label (self->os_type_row, os_type_text);
+
+ cc_list_row_set_secondary_label (self->windowing_system_row, get_windowing_system ());
+}
+
+static gboolean
+does_gnome_software_allow_updates (void)
+{
+ const gchar *schema_id = "org.gnome.software";
+ GSettingsSchemaSource *source;
+ g_autoptr(GSettingsSchema) schema = NULL;
+ g_autoptr(GSettings) settings = NULL;
+
+ source = g_settings_schema_source_get_default ();
+
+ if (source == NULL)
+ return FALSE;
+
+ schema = g_settings_schema_source_lookup (source, schema_id, FALSE);
+
+ if (schema == NULL)
+ return FALSE;
+
+ settings = g_settings_new (schema_id);
+ return g_settings_get_boolean (settings, "allow-updates");
+}
+
+static gboolean
+does_gnome_software_exist (void)
+{
+ g_autofree gchar *path = g_find_program_in_path ("gnome-software");
+ return path != NULL;
+}
+
+static gboolean
+does_gpk_update_viewer_exist (void)
+{
+ g_autofree gchar *path = g_find_program_in_path ("gpk-update-viewer");
+ return path != NULL;
+}
+
+static void
+open_software_update (CcInfoOverviewPanel *self)
+{
+ g_autoptr(GError) error = NULL;
+ gboolean ret;
+ char *argv[3];
+
+ if (does_gnome_software_exist ())
+ {
+ argv[0] = "gnome-software";
+ argv[1] = "--mode=updates";
+ argv[2] = NULL;
+ }
+ else
+ {
+ argv[0] = "gpk-update-viewer";
+ argv[1] = NULL;
+ }
+ ret = g_spawn_async (NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, &error);
+ if (!ret)
+ g_warning ("Failed to spawn %s: %s", argv[0], error->message);
+}
+
+static void
+on_device_name_entry_changed (CcInfoOverviewPanel *self)
+{
+ const gchar *current_hostname, *new_hostname;
+
+ current_hostname = gtk_editable_get_text (GTK_EDITABLE (self->hostname_entry));
+ new_hostname = gtk_editable_get_text (GTK_EDITABLE (self->device_name_entry));
+ gtk_widget_set_sensitive (self->rename_button,
+ g_strcmp0 (current_hostname, new_hostname) != 0);
+}
+
+static void
+update_device_name (CcInfoOverviewPanel *self)
+{
+ const gchar *hostname;
+
+ /* We simply change the CcHostnameEntry text. CcHostnameEntry
+ * listens to changes and updates hostname on change.
+ */
+ hostname = gtk_editable_get_text (GTK_EDITABLE (self->device_name_entry));
+ gtk_editable_set_text (GTK_EDITABLE (self->hostname_entry), hostname);
+}
+
+static void
+on_hostname_editor_dialog_response_cb (GtkDialog *dialog,
+ gint response,
+ CcInfoOverviewPanel *self)
+{
+ if (response == GTK_RESPONSE_APPLY)
+ {
+ update_device_name (self);
+ }
+
+ gtk_window_close (GTK_WINDOW (dialog));
+}
+
+static void
+on_device_name_entry_activated_cb (CcInfoOverviewPanel *self)
+{
+ update_device_name (self);
+ gtk_window_close (GTK_WINDOW (self->hostname_editor));
+}
+
+static void
+open_hostname_edit_dialog (CcInfoOverviewPanel *self)
+{
+ GtkWindow *toplevel;
+ CcShell *shell;
+ const gchar *hostname;
+
+ g_assert (CC_IS_INFO_OVERVIEW_PANEL (self));
+
+ shell = cc_panel_get_shell (CC_PANEL (self));
+ toplevel = GTK_WINDOW (cc_shell_get_toplevel (shell));
+ gtk_window_set_transient_for (GTK_WINDOW (self->hostname_editor), toplevel);
+
+ hostname = gtk_editable_get_text (GTK_EDITABLE (self->hostname_entry));
+ gtk_editable_set_text (GTK_EDITABLE (self->device_name_entry), hostname);
+ gtk_widget_grab_focus (GTK_WIDGET (self->device_name_entry));
+
+ gtk_window_present (GTK_WINDOW (self->hostname_editor));
+
+}
+
+static void
+cc_info_panel_row_activated_cb (CcInfoOverviewPanel *self,
+ AdwActionRow *row)
+{
+ g_assert (CC_IS_INFO_OVERVIEW_PANEL (self));
+ g_assert (ADW_IS_ACTION_ROW (row));
+
+ if (row == ADW_ACTION_ROW (self->hostname_row))
+ open_hostname_edit_dialog (self);
+ else if (row == self->software_updates_row)
+ open_software_update (self);
+}
+
+#if !defined(DISTRIBUTOR_LOGO) || defined(DARK_MODE_DISTRIBUTOR_LOGO)
+static gboolean
+use_dark_theme (CcInfoOverviewPanel *panel)
+{
+ AdwStyleManager *style_manager = adw_style_manager_get_default ();
+
+ return adw_style_manager_get_dark (style_manager);
+}
+#endif
+
+static void
+setup_os_logo (CcInfoOverviewPanel *panel)
+{
+#ifdef DISTRIBUTOR_LOGO
+#ifdef DARK_MODE_DISTRIBUTOR_LOGO
+ if (use_dark_theme (panel))
+ {
+ gtk_picture_set_filename (panel->os_logo, DARK_MODE_DISTRIBUTOR_LOGO);
+ return;
+ }
+#endif
+ gtk_picture_set_filename (panel->os_logo, DISTRIBUTOR_LOGO);
+ return;
+#else
+ GtkIconTheme *icon_theme;
+ g_autofree char *logo_name = g_get_os_info ("LOGO");
+ g_autoptr(GtkIconPaintable) icon_paintable = NULL;
+ g_autoptr(GPtrArray) array = NULL;
+ g_autoptr(GIcon) icon = NULL;
+ gboolean dark;
+
+ dark = use_dark_theme (panel);
+ if (logo_name == NULL)
+ logo_name = g_strdup ("gnome-logo");
+
+ array = g_ptr_array_new_with_free_func (g_free);
+ if (dark)
+ g_ptr_array_add (array, (gpointer) g_strdup_printf ("%s-text-dark", logo_name));
+ g_ptr_array_add (array, (gpointer) g_strdup_printf ("%s-text", logo_name));
+ if (dark)
+ g_ptr_array_add (array, (gpointer) g_strdup_printf ("%s-dark", logo_name));
+ g_ptr_array_add (array, (gpointer) g_strdup_printf ("%s", logo_name));
+
+ icon = g_themed_icon_new_from_names ((char **) array->pdata, array->len);
+ icon_theme = gtk_icon_theme_get_for_display (gdk_display_get_default ());
+ icon_paintable = gtk_icon_theme_lookup_by_gicon (icon_theme, icon,
+ 192,
+ gtk_widget_get_scale_factor (GTK_WIDGET (panel)),
+ gtk_widget_get_direction (GTK_WIDGET (panel)),
+ 0);
+ gtk_picture_set_paintable (panel->os_logo, GDK_PAINTABLE (icon_paintable));
+#endif
+}
+
+static void
+cc_info_overview_panel_class_init (CcInfoOverviewPanelClass *klass)
+{
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/info-overview/cc-info-overview-panel.ui");
+
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, device_name_entry);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, disk_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, gnome_version_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, graphics_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, hardware_model_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, hostname_editor);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, hostname_entry);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, hostname_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, memory_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, os_logo);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, os_name_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, os_build_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, os_type_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, processor_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, rename_button);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, software_updates_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, virtualization_row);
+ gtk_widget_class_bind_template_child (widget_class, CcInfoOverviewPanel, windowing_system_row);
+
+ gtk_widget_class_bind_template_callback (widget_class, cc_info_panel_row_activated_cb);
+ gtk_widget_class_bind_template_callback (widget_class, on_device_name_entry_changed);
+ gtk_widget_class_bind_template_callback (widget_class, on_device_name_entry_activated_cb);
+ gtk_widget_class_bind_template_callback (widget_class, on_hostname_editor_dialog_response_cb);
+
+ g_type_ensure (CC_TYPE_LIST_ROW);
+ g_type_ensure (CC_TYPE_HOSTNAME_ENTRY);
+}
+
+static void
+cc_info_overview_panel_init (CcInfoOverviewPanel *self)
+{
+ AdwStyleManager *style_manager;
+
+ gtk_widget_init_template (GTK_WIDGET (self));
+
+ g_resources_register (cc_info_overview_get_resource ());
+
+ if ((!does_gnome_software_exist () || !does_gnome_software_allow_updates ()) && !does_gpk_update_viewer_exist ())
+ gtk_widget_hide (GTK_WIDGET (self->software_updates_row));
+
+ info_overview_panel_setup_overview (self);
+ info_overview_panel_setup_virt (self);
+
+ style_manager = adw_style_manager_get_default ();
+ g_signal_connect_swapped (style_manager, "notify::dark", G_CALLBACK (setup_os_logo), self);
+ setup_os_logo (self);
+}
+
+GtkWidget *
+cc_info_overview_panel_new (void)
+{
+ return g_object_new (CC_TYPE_INFO_OVERVIEW_PANEL,
+ NULL);
+}