diff options
Diffstat (limited to 'panels/info-overview/cc-info-overview-panel.c')
| -rw-r--r-- | panels/info-overview/cc-info-overview-panel.c | 993 |
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); +} |