GCC Code Coverage Report

Line	Branch	Exec	Source
1			/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
2			*
3			* Copyright (C) 2023 Cyber Phantom <inam123451@gmail.com>
4			*
5			* This program is free software; you can redistribute it and/or modify
6			* it under the terms of the GNU General Public License as published by
7			* the Free Software Foundation; either version 2 of the License, or
8			* (at your option) any later version.
9			*
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			*
15			* You should have received a copy of the GNU General Public License
16			* along with this program; if not, see <http://www.gnu.org/licenses/>.
17			*
18			*/
19
20			#include <config.h>
21
22			#include "shell/cc-object-storage.h"
23
24			#include "info-cleanup.h"
25
26			#include <glib.h>
27			#include <glib/gi18n.h>
28			#include <gio/gio.h>
29			#include <gio/gunixmounts.h>
30			#include <gio/gdesktopappinfo.h>
31
32			#include <glibtop/fsusage.h>
33			#include <glibtop/mountlist.h>
34			#include <glibtop/mem.h>
35			#include <glibtop/sysinfo.h>
36			#include <udisks/udisks.h>
37			#include <gudev/gudev.h>
38
39			#include <gdk/gdk.h>
40
41			#ifdef GDK_WINDOWING_WAYLAND
42			#include <gdk/wayland/gdkwayland.h>
43			#endif
44			#ifdef GDK_WINDOWING_X11
45			#include <gdk/x11/gdkx.h>
46			#endif
47
48			#include "cc-system-details-window.h"
49			#include "cc-hostname.h"
50			#include "cc-info-entry.h"
51
52			struct _CcSystemDetailsWindow
53			{
54			AdwDialog parent;
55
56			AdwToastOverlay *toast_overlay;
57
58			/* Hardware Information */
59			CcInfoEntry *hardware_model_row;
60			CcInfoEntry *firmware_version_row;
61			CcInfoEntry *memory_row;
62			CcInfoEntry *processor_row;
63			GtkBox *graphics_row;
64			CcInfoEntry *disk_row;
65
66			/* Hardware Information */
67			CcInfoEntry *os_name_row;
68			CcInfoEntry *os_build_row;
69			CcInfoEntry *os_type_row;
70			CcInfoEntry *gnome_version_row;
71			CcInfoEntry *windowing_system_row;
72			CcInfoEntry *virtualization_row;
73			CcInfoEntry *kernel_row;
74			};
75
76		✗	G_DEFINE_TYPE (CcSystemDetailsWindow, cc_system_details_window, ADW_TYPE_DIALOG)
77
78			static char *
79		✗	get_renderer_from_session (void)
80			{
81		✗	g_autoptr(GDBusProxy) session_proxy = NULL;
82		✗	g_autoptr(GVariant) renderer_variant = NULL;
83			char *renderer;
84		✗	g_autoptr(GError) error = NULL;
85
86		✗	session_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
87			G_DBUS_PROXY_FLAGS_NONE,
88			NULL,
89			"org.gnome.SessionManager",
90			"/org/gnome/SessionManager",
91			"org.gnome.SessionManager",
92			NULL, &error);
93		✗	if (error != NULL)
94			{
95		✗	g_warning ("Unable to connect to create a proxy for org.gnome.SessionManager: %s",
96			error->message);
97		✗	return NULL;
98			}
99
100		✗	renderer_variant = g_dbus_proxy_get_cached_property (session_proxy, "Renderer");
101
102		✗	if (!renderer_variant)
103			{
104		✗	g_warning ("Unable to retrieve org.gnome.SessionManager.Renderer property");
105		✗	return NULL;
106			}
107
108		✗	renderer = info_cleanup (g_variant_get_string (renderer_variant, NULL));
109
110		✗	return renderer;
111			}
112
113			/* @env is an array of strings with each pair of strings being the
114			* key followed by the value */
115			static char *
116		✗	get_renderer_from_helper (const char **env)
117			{
118			int status;
119		✗	char *argv[] = { LIBEXECDIR "/gnome-control-center-print-renderer", NULL };
120		✗	g_auto(GStrv) envp = NULL;
121		✗	g_autofree char *renderer = NULL;
122		✗	g_autoptr(GError) error = NULL;
123
124		✗	g_debug ("About to launch '%s'", argv[0]);
125
126		✗	if (env != NULL)
127			{
128			guint i;
129		✗	g_debug ("With environment:");
130		✗	envp = g_get_environ ();
131		✗	for (i = 0; env != NULL && env[i] != NULL; i = i + 2)
132			{
133		✗	g_debug (" %s = %s", env[i], env[i+1]);
134		✗	envp = g_environ_setenv (envp, env[i], env[i+1], TRUE);
135			}
136			}
137			else
138			{
139		✗	g_debug ("No additional environment variables");
140			}
141
142		✗	if (!g_spawn_sync (NULL, (char **) argv, envp, 0, NULL, NULL, &renderer, NULL, &status, &error))
143			{
144		✗	g_debug ("Failed to get GPU: %s", error->message);
145		✗	return NULL;
146			}
147
148		✗	if (!g_spawn_check_wait_status (status, NULL))
149		✗	return NULL;
150
151		✗	if (renderer == NULL || *renderer == '\0')
152		✗	return NULL;
153
154		✗	return info_cleanup (renderer);
155			}
156
157			typedef struct {
158			char *name;
159			gboolean is_default;
160			} GpuData;
161
162			static int
163		✗	gpu_data_sort (gconstpointer a, gconstpointer b)
164			{
165		✗	GpuData *gpu_a = (GpuData *) a;
166		✗	GpuData *gpu_b = (GpuData *) b;
167
168		✗	if (gpu_a->is_default)
169		✗	return -1;
170		✗	if (gpu_b->is_default)
171		✗	return 1;
172		✗	return 0;
173			}
174
175			static GSList *
176		✗	get_renderer_from_switcheroo (void)
177			{
178		✗	g_autoptr(GDBusProxy) switcheroo_proxy = NULL;
179		✗	g_autoptr(GVariant) variant = NULL;
180		✗	g_autoptr(GError) error = NULL;
181			guint i, num_children;
182			GSList *renderers;
183
184		✗	switcheroo_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
185			G_DBUS_PROXY_FLAGS_NONE,
186			NULL,
187			"net.hadess.SwitcherooControl",
188			"/net/hadess/SwitcherooControl",
189			"net.hadess.SwitcherooControl",
190			NULL, &error);
191		✗	if (switcheroo_proxy == NULL)
192			{
193		✗	g_debug ("Unable to connect to create a proxy for net.hadess.SwitcherooControl: %s",
194			error->message);
195		✗	return NULL;
196			}
197
198		✗	variant = g_dbus_proxy_get_cached_property (switcheroo_proxy, "GPUs");
199
200		✗	if (!variant)
201			{
202		✗	g_debug ("Unable to retrieve net.hadess.SwitcherooControl.GPUs property, the daemon is likely not running");
203		✗	return NULL;
204			}
205
206		✗	num_children = g_variant_n_children (variant);
207		✗	renderers = NULL;
208		✗	for (i = 0; i < num_children; i++)
209			{
210		✗	g_autoptr(GVariant) gpu;
211		✗	g_autoptr(GVariant) name = NULL;
212		✗	g_autoptr(GVariant) env = NULL;
213		✗	g_autoptr(GVariant) default_variant = NULL;
214			const char *name_s;
215		✗	g_autofree const char **env_s = NULL;
216			gsize env_len;
217		✗	g_autofree char *renderer = NULL;
218			GpuData *gpu_data;
219
220		✗	gpu = g_variant_get_child_value (variant, i);
221		✗	if (!gpu ||
222		✗	!g_variant_is_of_type (gpu, G_VARIANT_TYPE ("a{s*}")))
223		✗	continue;
224
225		✗	name = g_variant_lookup_value (gpu, "Name", NULL);
226		✗	env = g_variant_lookup_value (gpu, "Environment", NULL);
227		✗	if (!name || !env)
228		✗	continue;
229		✗	name_s = g_variant_get_string (name, NULL);
230		✗	g_debug ("Getting renderer from helper for GPU '%s'", name_s);
231		✗	env_s = g_variant_get_strv (env, &env_len);
232		✗	if (env_s != NULL && env_len % 2 != 0)
233			{
234		✗	g_autofree char *debug = NULL;
235		✗	debug = g_strjoinv ("\n", (char **) env_s);
236		✗	g_warning ("Invalid environment returned from switcheroo:\n%s", debug);
237		✗	g_clear_pointer (&env_s, g_free);
238			}
239
240		✗	renderer = get_renderer_from_helper (env_s);
241		✗	default_variant = g_variant_lookup_value (gpu, "Default", NULL);
242
243			/* We could give up if we don't have a renderer, but that
244			* might just mean gnome-session isn't installed. We fall back
245			* to the device name in udev instead, which is better than nothing */
246
247		✗	gpu_data = g_new0 (GpuData, 1);
248		✗	gpu_data->name = g_strdup (renderer ? renderer : name_s);
249		✗	gpu_data->is_default = default_variant ? g_variant_get_boolean (default_variant) : FALSE;
250		✗	renderers = g_slist_prepend (renderers, gpu_data);
251			}
252
253		✗	renderers = g_slist_sort (renderers, gpu_data_sort);
254
255		✗	return renderers;
256			}
257
258			static GSList *
259		✗	get_graphics_hardware_list (void)
260			{
261		✗	GSList *renderers = NULL;
262
263		✗	renderers = get_renderer_from_switcheroo ();
264
265		✗	if (!renderers)
266			{
267			GpuData *gpu_data;
268		✗	g_autofree char *renderer;
269		✗	renderer = get_renderer_from_session ();
270		✗	if (!renderer)
271		✗	renderer = get_renderer_from_helper (NULL);
272		✗	if (!renderer)
273		✗	renderer = g_strdup (_("Unknown"));
274
275		✗	gpu_data = g_new0 (GpuData, 1);
276		✗	gpu_data->name = g_strdup (renderer);
277		✗	gpu_data->is_default = TRUE;
278		✗	renderers = g_slist_prepend (renderers, gpu_data);
279			}
280
281		✗	return renderers;
282			}
283
284
285			static void
286		✗	create_graphics_rows (CcSystemDetailsWindow *self, GSList *devices)
287			{
288			GSList *l;
289		✗	guint i = 0;
290			GtkWidget *gpu_entry;
291
292		✗	for (l = devices; l != NULL; l = l->next)
293			{
294		✗	GpuData *data = l->data;
295		✗	g_autofree char *name = data->name;
296		✗	g_autofree char *label = NULL;
297
298		✗	if (data->is_default)
299		✗	label = g_strdup (_("Graphics"));
300			else
301		✗	label = g_strdup_printf (_("Graphics %d"), ++i);
302
303		✗	gpu_entry = cc_info_entry_new (label, name);
304
305		✗	gtk_box_append (self->graphics_row, gpu_entry);
306			}
307		✗	}
308
309			char *
310		✗	get_os_name (void)
311			{
312		✗	g_autofree gchar *name = NULL;
313		✗	g_autofree gchar *version_id = NULL;
314		✗	g_autofree gchar *pretty_name = NULL;
315
316		✗	name = g_get_os_info (G_OS_INFO_KEY_NAME);
317		✗	version_id = g_get_os_info (G_OS_INFO_KEY_VERSION_ID);
318		✗	pretty_name = g_get_os_info (G_OS_INFO_KEY_PRETTY_NAME);
319
320		✗	if (pretty_name)
321		✗	return g_steal_pointer (&pretty_name);
322		✗	else if (name && version_id)
323		✗	return g_strdup_printf ("%s %s", name, version_id);
324			else
325		✗	return g_strdup (_("Unknown"));
326			}
327
328			static char *
329		✗	get_os_build_id (void)
330			{
331		✗	char *build_id = NULL;
332
333		✗	build_id = g_get_os_info ("BUILD_ID");
334
335		✗	return build_id;
336			}
337
338			static char *
339		✗	get_os_type (void)
340			{
341			if (GLIB_SIZEOF_VOID_P == 8)
342			/* translators: This is the type of architecture for the OS */
343		✗	return g_strdup_printf (_("64-bit"));
344			else
345			/* translators: This is the type of architecture for the OS */
346			return g_strdup_printf (_("32-bit"));
347			}
348
349			char *
350		✗	get_primary_disk_info (void)
351			{
352		✗	g_autoptr(UDisksClient) client = NULL;
353			GDBusObjectManager *manager;
354		✗	g_autolist(GDBusObject) objects = NULL;
355			GList *l;
356			guint64 total_size;
357		✗	g_autoptr(GError) error = NULL;
358
359		✗	total_size = 0;
360
361		✗	client = udisks_client_new_sync (NULL, &error);
362		✗	if (client == NULL)
363			{
364		✗	g_warning ("Unable to get UDisks client: %s. Disk information will not be available.",
365			error->message);
366		✗	return NULL;
367			}
368
369		✗	manager = udisks_client_get_object_manager (client);
370		✗	objects = g_dbus_object_manager_get_objects (manager);
371
372		✗	for (l = objects; l != NULL; l = l->next)
373			{
374			UDisksDrive *drive;
375		✗	drive = udisks_object_peek_drive (UDISKS_OBJECT (l->data));
376
377			/* Skip removable devices */
378		✗	if (drive == NULL ||
379		✗	udisks_drive_get_removable (drive) ||
380		✗	udisks_drive_get_ejectable (drive))
381			{
382		✗	continue;
383			}
384
385		✗	total_size += udisks_drive_get_size (drive);
386			}
387
388		✗	if (total_size > 0)
389		✗	return g_format_size (total_size);
390
391		✗	return NULL;
392			}
393
394			char *
395		✗	get_hardware_model_string (void)
396			{
397		✗	g_autofree char *vendor_string = NULL;
398		✗	g_autofree char *model_string = NULL;
399
400		✗	vendor_string = cc_hostname_get_property (cc_hostname_get_default (), "HardwareVendor");
401		✗	if (!vendor_string || g_strcmp0 (vendor_string, "") == 0)
402		✗	return NULL;
403
404		✗	model_string = cc_hostname_get_property (cc_hostname_get_default (), "HardwareModel");
405		✗	if (!model_string || g_strcmp0 (model_string, "") == 0)
406		✗	return NULL;
407
408		✗	return g_strdup_printf ("%s %s", vendor_string, model_string);
409			}
410
411			static char *
412		✗	get_firmware_version_string ()
413			{
414		✗	g_autofree char *firmware_version_string = NULL;
415
416		✗	firmware_version_string = cc_hostname_get_property (cc_hostname_get_default (), "FirmwareVersion");
417		✗	if (!firmware_version_string || g_strcmp0 (firmware_version_string, "") == 0)
418		✗	return NULL;
419
420		✗	return g_steal_pointer (&firmware_version_string);
421			}
422
423			static char *
424		✗	get_kernel_version_string ()
425			{
426		✗	g_autofree char *kernel_name = NULL;
427		✗	g_autofree char *kernel_release = NULL;
428
429		✗	kernel_name = cc_hostname_get_property (cc_hostname_get_default (), "KernelName");
430		✗	if (!kernel_name || g_strcmp0 (kernel_name, "") == 0)
431		✗	return NULL;
432
433		✗	kernel_release = cc_hostname_get_property (cc_hostname_get_default (), "KernelRelease");
434		✗	if (!kernel_release || g_strcmp0 (kernel_release, "") == 0)
435		✗	return NULL;
436
437		✗	return g_strdup_printf ("%s %s", kernel_name, kernel_release);
438			}
439
440			char *
441		✗	get_cpu_info ()
442			{
443		✗	g_autoptr(GHashTable) counts = NULL;
444		✗	g_autoptr(GString) cpu = NULL;
445			const glibtop_sysinfo *info;
446			GHashTableIter iter;
447			gpointer key, value;
448			int i;
449			int j;
450
451		✗	counts = g_hash_table_new (g_str_hash, g_str_equal);
452		✗	info = glibtop_get_sysinfo ();
453
454			/* count duplicates */
455		✗	for (i = 0; i != info->ncpu; ++i)
456			{
457		✗	const char * const keys[] = { "model name", "cpu", "Processor", "Model Name" };
458			char *model;
459			int *count;
460
461		✗	model = NULL;
462
463		✗	for (j = 0; model == NULL && j != G_N_ELEMENTS (keys); ++j)
464			{
465		✗	model = g_hash_table_lookup (info->cpuinfo[i].values,
466		✗	keys[j]);
467			}
468
469		✗	if (model == NULL)
470		✗	continue;
471
472		✗	count = g_hash_table_lookup (counts, model);
473		✗	if (count == NULL)
474		✗	g_hash_table_insert (counts, model, GINT_TO_POINTER (1));
475			else
476		✗	g_hash_table_replace (counts, model, GINT_TO_POINTER (GPOINTER_TO_INT (count) + 1));
477			}
478
479		✗	cpu = g_string_new (NULL);
480		✗	g_hash_table_iter_init (&iter, counts);
481		✗	while (g_hash_table_iter_next (&iter, &key, &value))
482			{
483		✗	g_autofree char *cleanedup = NULL;
484			int count;
485
486		✗	count = GPOINTER_TO_INT (value);
487		✗	cleanedup = info_cleanup ((const char *) key);
488		✗	if (cpu->len != 0)
489		✗	g_string_append_printf (cpu, " ");
490		✗	if (count > 1)
491		✗	g_string_append_printf (cpu, "%s \303\227 %d", cleanedup, count);
492			else
493		✗	g_string_append_printf (cpu, "%s", cleanedup);
494			}
495
496		✗	return g_strdup (cpu->str);
497			}
498
499			static struct {
500			const char *id;
501			const char *display;
502			} const virt_tech[] = {
503			{ "kvm", "KVM" },
504			{ "qemu", "QEmu" },
505			{ "vmware", "VMware" },
506			{ "microsoft", "Microsoft" },
507			{ "oracle", "Oracle" },
508			{ "xen", "Xen" },
509			{ "bochs", "Bochs" },
510			{ "chroot", "chroot" },
511			{ "openvz", "OpenVZ" },
512			{ "lxc", "LXC" },
513			{ "lxc-libvirt", "LXC (libvirt)" },
514			{ "systemd-nspawn", "systemd (nspawn)" }
515			};
516
517			static void
518		✗	set_virtualization_label (CcSystemDetailsWindow *self,
519			const char *virt)
520			{
521			const char *display_name;
522			guint i;
523
524		✗	if (virt == NULL || *virt == '\0')
525			{
526		✗	gtk_widget_set_visible (GTK_WIDGET (self->virtualization_row), FALSE);
527
528		✗	return;
529			}
530
531		✗	gtk_widget_set_visible (GTK_WIDGET (self->firmware_version_row), FALSE);
532
533		✗	gtk_widget_set_visible (GTK_WIDGET (self->virtualization_row), TRUE);
534
535		✗	display_name = NULL;
536		✗	for (i = 0; i < G_N_ELEMENTS (virt_tech); i++)
537			{
538		✗	if (g_str_equal (virt_tech[i].id, virt))
539			{
540		✗	display_name = _(virt_tech[i].display);
541		✗	break;
542			}
543			}
544
545		✗	cc_info_entry_set_value (self->virtualization_row, display_name ? display_name : virt);
546			}
547
548			static void
549		✗	system_details_window_setup_virt (CcSystemDetailsWindow *self)
550			{
551		✗	g_autoptr(GError) error = NULL;
552		✗	g_autoptr(GDBusProxy) systemd_proxy = NULL;
553		✗	g_autoptr(GVariant) variant = NULL;
554			GVariant *inner;
555
556		✗	systemd_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
557			G_DBUS_PROXY_FLAGS_NONE,
558			NULL,
559			"org.freedesktop.systemd1",
560			"/org/freedesktop/systemd1",
561			"org.freedesktop.systemd1",
562			NULL,
563			&error);
564
565		✗	if (systemd_proxy == NULL)
566			{
567		✗	g_debug ("systemd not available, bailing: %s", error->message);
568		✗	set_virtualization_label (self, NULL);
569		✗	return;
570			}
571
572		✗	variant = g_dbus_proxy_call_sync (systemd_proxy,
573			"org.freedesktop.DBus.Properties.Get",
574			g_variant_new ("(ss)", "org.freedesktop.systemd1.Manager", "Virtualization"),
575			G_DBUS_CALL_FLAGS_NONE,
576			-1,
577			NULL,
578			&error);
579		✗	if (variant == NULL)
580			{
581		✗	g_debug ("Failed to get property '%s': %s", "Virtualization", error->message);
582		✗	set_virtualization_label (self, NULL);
583		✗	return;
584			}
585
586		✗	g_variant_get (variant, "(v)", &inner);
587		✗	set_virtualization_label (self, g_variant_get_string (inner, NULL));
588			}
589
590			static const char *
591		✗	get_windowing_system (void)
592			{
593			GdkDisplay *display;
594
595		✗	display = gdk_display_get_default ();
596
597			#if defined(GDK_WINDOWING_X11)
598		✗	if (GDK_IS_X11_DISPLAY (display))
599		✗	return _("X11");
600			#endif /* GDK_WINDOWING_X11 */
601			#if defined(GDK_WINDOWING_WAYLAND)
602		✗	if (GDK_IS_WAYLAND_DISPLAY (display))
603		✗	return _("Wayland");
604			#endif /* GDK_WINDOWING_WAYLAND */
605		✗	return C_("Windowing system (Wayland, X11, or Unknown)", "Unknown");
606			}
607
608			guint64
609		✗	get_ram_size_libgtop (void)
610			{
611			glibtop_mem mem;
612
613		✗	glibtop_get_mem (&mem);
614		✗	return mem.total;
615			}
616
617			guint64
618		✗	get_ram_size_dmi (void)
619			{
620		✗	g_autoptr(GUdevClient) client = NULL;
621		✗	g_autoptr(GUdevDevice) dmi = NULL;
622		✗	const gchar * const subsystems[] = {"dmi", NULL };
623		✗	guint64 ram_total = 0;
624			guint64 num_ram;
625			guint i;
626
627		✗	client = g_udev_client_new (subsystems);
628		✗	dmi = g_udev_client_query_by_sysfs_path (client, "/sys/devices/virtual/dmi/id");
629		✗	if (!dmi)
630		✗	return 0;
631		✗	num_ram = g_udev_device_get_property_as_uint64 (dmi, "MEMORY_ARRAY_NUM_DEVICES");
632		✗	for (i = 0; i < num_ram ; i++) {
633		✗	g_autofree char *prop = NULL;
634
635		✗	prop = g_strdup_printf ("MEMORY_DEVICE_%d_SIZE", i);
636		✗	ram_total += g_udev_device_get_property_as_uint64 (dmi, prop);
637			}
638		✗	return ram_total;
639			}
640
641			static void
642		✗	system_details_window_title_print_padding (const gchar *title, GString *dst_string, gsize maxlen)
643			{
644			gsize title_len;
645		✗	gsize maxpad = maxlen;
646
647		✗	if (maxlen == 0)
648		✗	maxpad = 50;
649
650		✗	if (title == NULL || dst_string == NULL)
651		✗	return;
652		✗	g_string_append_printf (dst_string, "%s", title);
653
654		✗	title_len = g_utf8_strlen (title, -1) + 1;
655		✗	for (gsize i = title_len; i < maxpad; i++)
656		✗	g_string_append (dst_string, " ");
657			}
658
659			static void
660		✗	on_copy_button_clicked_cb (GtkWidget *widget,
661			CcSystemDetailsWindow *self)
662			{
663			GdkClipboard *clip_board;
664			GdkDisplay *display;
665		✗	g_autofree gchar *date_string = NULL;
666		✗	g_autoptr (GDateTime) date = NULL;
667			guint64 ram_size;
668		✗	g_autofree char *memory_text = NULL;
669		✗	g_autofree char *cpu_text = NULL;
670		✗	g_autofree char *os_type_text = NULL;
671		✗	g_autofree char *os_name_text = NULL;
672		✗	g_autofree char *os_build_text = NULL;
673		✗	g_autofree char *hardware_model_text = NULL;
674		✗	g_autofree char *firmware_version_text = NULL;
675		✗	g_autofree char *windowing_system_text = NULL;
676		✗	g_autofree char *kernel_version_text = NULL;
677		✗	g_autofree GSList *graphics_hardware_list, *l;
678		✗	g_autofree gchar *disk_capacity_string = NULL;
679
680		✗	g_autoptr (GString) result_str;
681
682		✗	result_str = g_string_new (NULL);
683
684		✗	g_string_append (result_str, _("# System Details Report\n"));
685		✗	g_string_append (result_str, "---\n\n");
686
687		✗	g_string_append (result_str, _("## Report details\n"));
688
689		✗	g_string_append (result_str, "- ");
690		✗	system_details_window_title_print_padding (_("**Date generated:**"), result_str, 0);
691		✗	date = g_date_time_new_now_local ();
692		✗	date_string = g_date_time_format (date, "%Y-%m-%d %H:%M:%S");
693
694		✗	g_string_append_printf (result_str, "%s\n\n", date_string);
695
696		✗	g_string_append (result_str, _("## Hardware Information:\n"));
697
698		✗	g_string_append (result_str, "- ");
699		✗	system_details_window_title_print_padding (_("**Hardware Model:**"), result_str, 0);
700		✗	hardware_model_text = get_hardware_model_string ();
701		✗	g_string_append_printf (result_str, "%s\n", hardware_model_text);
702
703		✗	g_string_append (result_str, "- ");
704		✗	system_details_window_title_print_padding (_("**Memory:**"), result_str, 0);
705		✗	ram_size = get_ram_size_dmi ();
706		✗	if (ram_size == 0)
707		✗	ram_size = get_ram_size_libgtop ();
708		✗	memory_text = g_format_size_full (ram_size, G_FORMAT_SIZE_IEC_UNITS);
709		✗	g_string_append_printf (result_str, "%s\n", memory_text);
710
711		✗	g_string_append (result_str, "- ");
712		✗	system_details_window_title_print_padding (_("**Processor:**"), result_str, 0);
713		✗	cpu_text = get_cpu_info ();
714		✗	g_string_append_printf (result_str, "%s\n", cpu_text);
715
716		✗	graphics_hardware_list = get_graphics_hardware_list ();
717		✗	guint i = 0;
718
719		✗	for (l = graphics_hardware_list; l != NULL; l = l->next)
720			{
721		✗	GpuData *data = l->data;
722		✗	g_autofree char *name = data->name;
723		✗	g_autofree char *label = NULL;
724
725		✗	if (data->is_default)
726		✗	label = g_strdup (_("**Graphics:**"));
727			else
728		✗	label = g_strdup_printf (_("**Graphics %d:**"), ++i);
729		✗	g_string_append (result_str, "- ");
730		✗	system_details_window_title_print_padding (label, result_str, 0);
731		✗	g_string_append_printf (result_str, "%s\n", name);
732			}
733
734		✗	g_string_append (result_str, "- ");
735		✗	system_details_window_title_print_padding (_("**Disk Capacity:**"), result_str, 0);
736		✗	disk_capacity_string = get_primary_disk_info ();
737		✗	g_string_append_printf (result_str, "%s\n", disk_capacity_string);
738
739		✗	g_string_append (result_str, "\n");
740
741		✗	g_string_append (result_str, _("## Software Information:\n"));
742
743		✗	g_string_append (result_str, "- ");
744		✗	system_details_window_title_print_padding (_("**Firmware Version:**"), result_str, 0);
745		✗	firmware_version_text = get_firmware_version_string ();
746		✗	g_string_append_printf (result_str, "%s\n", firmware_version_text);
747
748		✗	g_string_append (result_str, "- ");
749		✗	system_details_window_title_print_padding (_("**OS Name:**"), result_str, 0);
750		✗	os_name_text = get_os_name ();
751		✗	g_string_append_printf (result_str, "%s\n", os_name_text);
752
753		✗	g_string_append (result_str, "- ");
754		✗	system_details_window_title_print_padding (_("**OS Build:**"), result_str, 0);
755		✗	os_build_text = get_os_build_id ();
756		✗	g_string_append_printf (result_str, "%s\n", os_build_text);
757
758		✗	g_string_append (result_str, "- ");
759		✗	system_details_window_title_print_padding (_("**OS Type:**"), result_str, 0);
760		✗	os_type_text = get_os_type ();
761		✗	g_string_append_printf (result_str, "%s\n", os_type_text);
762
763		✗	g_string_append (result_str, "- ");
764		✗	system_details_window_title_print_padding (_("**GNOME Version:**"), result_str, 0);
765		✗	g_string_append_printf (result_str, "%s\n", MAJOR_VERSION);
766
767		✗	g_string_append (result_str, "- ");
768		✗	system_details_window_title_print_padding (_("**Windowing System:**"), result_str, 0);
769		✗	g_string_append_printf (result_str, "%s\n", get_windowing_system ());
770
771		✗	g_string_append (result_str, "- ");
772		✗	system_details_window_title_print_padding (_("**Kernel Version:**"), result_str, 0);
773		✗	kernel_version_text = get_kernel_version_string ();
774		✗	g_string_append_printf (result_str, "%s\n", kernel_version_text);
775
776		✗	display = gdk_display_get_default ();
777		✗	clip_board = gdk_display_get_clipboard (display);
778		✗	gdk_clipboard_set_text (clip_board, result_str->str);
779		✗	adw_toast_overlay_add_toast (self->toast_overlay, adw_toast_new (_("Details copied to clipboard")));
780		✗	}
781
782			static void
783		✗	system_details_window_setup_overview (CcSystemDetailsWindow *self)
784			{
785			guint64 ram_size;
786		✗	g_autofree char *memory_text = NULL;
787		✗	g_autofree char *cpu_text = NULL;
788		✗	g_autofree char *os_type_text = NULL;
789		✗	g_autofree char *os_name_text = NULL;
790		✗	g_autofree char *os_build_text = NULL;
791		✗	g_autofree char *hardware_model_text = NULL;
792		✗	g_autofree char *firmware_version_text = NULL;
793		✗	g_autofree char *kernel_version_text = NULL;
794		✗	g_autofree GSList *graphics_hardware_list = NULL;
795		✗	g_autofree gchar *disk_capacity_string = NULL;
796
797		✗	hardware_model_text = get_hardware_model_string ();
798		✗	cc_info_entry_set_value (self->hardware_model_row, hardware_model_text);
799		✗	gtk_widget_set_visible (GTK_WIDGET (self->hardware_model_row), hardware_model_text != NULL);
800
801		✗	firmware_version_text = get_firmware_version_string ();
802		✗	cc_info_entry_set_value (self->firmware_version_row, firmware_version_text);
803		✗	gtk_widget_set_visible (GTK_WIDGET (self->firmware_version_row), firmware_version_text != NULL);
804
805		✗	ram_size = get_ram_size_dmi ();
806		✗	if (ram_size == 0)
807		✗	ram_size = get_ram_size_libgtop ();
808		✗	memory_text = g_format_size_full (ram_size, G_FORMAT_SIZE_IEC_UNITS);
809		✗	cc_info_entry_set_value (self->memory_row, memory_text);
810
811		✗	cpu_text = get_cpu_info ();
812		✗	cc_info_entry_set_value (self->processor_row, cpu_text);
813
814		✗	graphics_hardware_list = get_graphics_hardware_list ();
815		✗	create_graphics_rows (self, graphics_hardware_list);
816
817		✗	disk_capacity_string = get_primary_disk_info ();
818		✗	if (disk_capacity_string == NULL)
819		✗	disk_capacity_string = g_strdup (_("Unknown"));
820		✗	cc_info_entry_set_value (self->disk_row, disk_capacity_string);
821
822		✗	os_name_text = get_os_name ();
823		✗	cc_info_entry_set_value (self->os_name_row, os_name_text);
824
825		✗	os_build_text = get_os_build_id ();
826		✗	cc_info_entry_set_value (self->os_build_row, os_build_text);
827		✗	gtk_widget_set_visible (GTK_WIDGET (self->os_build_row), os_build_text != NULL);
828
829		✗	os_type_text = get_os_type ();
830		✗	cc_info_entry_set_value (self->os_type_row, os_type_text);
831
832		✗	cc_info_entry_set_value (self->gnome_version_row, MAJOR_VERSION);
833
834		✗	cc_info_entry_set_value (self->windowing_system_row, get_windowing_system ());
835
836		✗	kernel_version_text = get_kernel_version_string ();
837		✗	cc_info_entry_set_value (self->kernel_row, kernel_version_text);
838		✗	gtk_widget_set_visible (GTK_WIDGET (self->kernel_row), kernel_version_text != NULL);
839		✗	}
840
841			static void
842		✗	unset_focus (CcSystemDetailsWindow *self)
843			{
844			GtkWidget *focus;
845
846		✗	focus = adw_dialog_get_focus (ADW_DIALOG (self));
847		✗	if (GTK_IS_LABEL (focus))
848		✗	gtk_label_select_region (GTK_LABEL (focus), 0, 0);
849		✗	adw_dialog_set_focus (ADW_DIALOG (self), NULL);
850		✗	}
851
852			static void
853		✗	cc_system_details_window_class_init (CcSystemDetailsWindowClass *klass)
854			{
855		✗	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
856
857		✗	gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/system/about/cc-system-details-window.ui");
858
859		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, toast_overlay);
860		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, disk_row);
861		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, gnome_version_row);
862		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, graphics_row);
863		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, hardware_model_row);
864		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, firmware_version_row);
865		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, kernel_row);
866		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, memory_row);
867		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, os_name_row);
868		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, os_build_row);
869		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, os_type_row);
870		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, processor_row);
871		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, virtualization_row);
872		✗	gtk_widget_class_bind_template_child (widget_class, CcSystemDetailsWindow, windowing_system_row);
873
874		✗	gtk_widget_class_bind_template_callback (widget_class, on_copy_button_clicked_cb);
875
876		✗	g_type_ensure (CC_TYPE_INFO_ENTRY);
877		✗	}
878
879			static void
880		✗	cc_system_details_window_init (CcSystemDetailsWindow *self)
881			{
882		✗	gtk_widget_init_template (GTK_WIDGET (self));
883
884		✗	system_details_window_setup_overview (self);
885		✗	system_details_window_setup_virt (self);
886
887			/* Workaround for issue gtk#4377, taken from gnome-software. See issue #2636. */
888		✗	g_signal_connect_after (self, "show", G_CALLBACK (unset_focus), NULL);
889		✗	}
890
891			CcSystemDetailsWindow *
892		✗	cc_system_details_window_new (void)
893			{
894		✗	return g_object_new (CC_TYPE_SYSTEM_DETAILS_WINDOW,
895			NULL);
896			}
897