/* * Copyright (C) 2018, Matthias Clasen * Copyright (C) 2024 GNOME Foundation, Inc. * * This file is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation, version 3.0 of the * License. * * This file is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this program. If not, see . * * SPDX-License-Identifier: LGPL-3.0-only * * Authors: * Matthias Clasen * Hubert Figuière */ #include "config.h" #include #include #include #include #include #include #include #include #include #include #include "libportal/settings.h" #include "libportal/portal-gtk3.h" #include "portal-test-app.h" #include "portal-test-win.h" #ifdef GDK_WINDOWING_X11 #include #endif #ifdef GDK_WINDOWING_WAYLAND #include #endif struct _PortalTestWin { GtkApplicationWindow parent; GtkWidget *sandbox_status; GtkWidget *network_status; GtkWidget *monitor_name; GtkWidget *resolver_name; GtkWidget *proxies; GtkWidget *encoding; GtkWidget *ack_image; XdpPortal *portal; XdpSession *session; XdpInputCaptureSession *input_capture_session; GNetworkMonitor *monitor; GProxyResolver *resolver; GtkWidget *image; GtkWidget *interactive; GtkWidget *inhibit_idle; GtkWidget *inhibit_logout; GtkWidget *inhibit_suspend; GtkWidget *inhibit_switch; int inhibit_cookie; GtkApplicationInhibitFlags inhibit_flags; GtkWidget *username; GtkWidget *realname; GtkWidget *avatar; GtkWidget *save_how; GtkWidget *open_local_ask; GtkWidget *open_local_dir; GtkWidget *file_chooser_button; XdpSettings *settings; GtkWidget *settings_value; GtkWidget *settings_count; GtkWidget *screencast_label; GtkWidget *screencast_toggle; GtkWidget *remotedesktop_label; GtkWidget *remotedesktop_toggle; GtkWidget *inputcapture_label; GtkWidget *inputcapture_toggle; GFileMonitor *update_monitor; GtkWidget *update_dialog; GtkWidget *update_dialog2; GtkWidget *update_progressbar; GtkWidget *update_label; GtkWidget *ok2; GtkWidget *clipboard_label; GtkWidget *clipboard_copy; GtkWidget *clipboard_paste; GtkWidget *clipboard_entry; gulong selection_owner_changed; gulong selection_transfer_handler_id; }; struct _PortalTestWinClass { GtkApplicationWindowClass parent_class; }; G_DEFINE_TYPE (PortalTestWin, portal_test_win, GTK_TYPE_APPLICATION_WINDOW); #define TEST_FILE_PATH APPDATADIR ".Gtk3/test.txt" static void update_clipboard (PortalTestWin *win); static char * file_path_in_source_dir (const char *file) { if (g_getenv ("MESON_SOURCE_ROOT") == NULL) g_warning ("MESON_SOURCE_ROOT was not set, run this application using `ninja portal-test-gtk3`"); return g_build_filename (g_getenv ("MESON_SOURCE_ROOT"), "portal-test", "gtk3", file, NULL); } static void update_network_status (PortalTestWin *win) { g_autoptr(GString) s = g_string_new (""); GEnumClass *class; GEnumValue *value; if (g_network_monitor_get_network_available (win->monitor)) g_string_append (s, "available"); if (g_network_monitor_get_network_metered (win->monitor)) { if (s->len > 0) g_string_append (s, ", "); g_string_append (s, "metered"); } class = g_type_class_ref (G_TYPE_NETWORK_CONNECTIVITY); value = g_enum_get_value (class, g_network_monitor_get_connectivity (win->monitor)); if (s->len > 0) g_string_append (s, ", "); g_string_append_printf (s, "connectivity=%s", value->value_nick); g_type_class_unref (class); gtk_label_set_label (GTK_LABEL (win->network_status), s->str); } static gboolean show_restart_dialog (gpointer data) { PortalTestWin *win = data; if (gtk_widget_get_visible (win->update_dialog2)) return G_SOURCE_CONTINUE; gtk_window_present (GTK_WINDOW (win->update_dialog)); return G_SOURCE_REMOVE; } static void update_monitor_changed (GFileMonitor *monitor, GFile *file, GFile *other, GFileMonitorEvent event, PortalTestWin *win) { if (event == G_FILE_MONITOR_EVENT_CREATED) g_timeout_add_seconds (5, show_restart_dialog, win); } static void update_dialog_response (GtkDialog *dialog, int response, PortalTestWin *win) { if (response == GTK_RESPONSE_OK) portal_test_app_restart (PORTAL_TEST_APP (gtk_window_get_application (GTK_WINDOW (win)))); gtk_widget_hide (win->update_dialog); } static void update_available (XdpPortal *portal, const char *running, const char *local, const char *remote, PortalTestWin *win) { g_message ("Update available"); gtk_label_set_label (GTK_LABEL (win->update_label), "Update available"); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (win->update_progressbar), 0.0); gtk_window_present (GTK_WINDOW (win->update_dialog2)); } static void update_progress (XdpPortal *portal, guint n_ops, guint op, guint progress, int status, const char *error, const char *message, PortalTestWin *win) { g_message ("Progress!"); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (win->update_progressbar), progress / 100.0); if (status == XDP_UPDATE_STATUS_FAILED) { gtk_label_set_label (GTK_LABEL (win->update_label), "Something went wrong"); gtk_widget_hide (win->update_progressbar); } else if (status == XDP_UPDATE_STATUS_DONE) { gtk_label_set_label (GTK_LABEL (win->update_label), "Installed"); } if (status != XDP_UPDATE_STATUS_RUNNING) g_signal_handlers_disconnect_by_func (win->portal, update_progress, win); } static void update_called (GObject *source, GAsyncResult *result, gpointer data) { PortalTestWin *win = data; g_autoptr(GError) error = NULL; if (!xdp_portal_update_install_finish (win->portal, result, &error)) { g_warning ("Installation failed: %s", error->message); gtk_widget_hide (win->update_dialog2); } gtk_label_set_label (GTK_LABEL (win->update_label), "Installing…"); gtk_widget_set_sensitive (win->ok2, FALSE); g_signal_connect (win->portal, "update-progress", G_CALLBACK (update_progress), win); } static void update_dialog2_response (GtkDialog *dialog, int response, PortalTestWin *win) { if (response == GTK_RESPONSE_OK) { XdpParent *parent = xdp_parent_new_gtk (GTK_WINDOW (win)); xdp_portal_update_install (win->portal, parent, 0, NULL, update_called, win); xdp_parent_free (parent); } else { g_signal_handlers_disconnect_by_func (win->portal, update_available, win); gtk_widget_hide (win->update_dialog2); } } static void reload_settings (PortalTestWin *win, GtkButton* button) { g_autoptr(GError) error = NULL; const char *ns[] = { "org.freedesktop.appearance", NULL }; guint32 value = xdp_settings_read_uint (win->settings, ns[0], "contrast", NULL, &error); g_autoptr(GVariant) value2 = NULL; if (!error) { guint32 uvalue2; g_autofree char *label = g_strdup_printf ("got %u", value); gtk_label_set_text (GTK_LABEL (win->settings_value), label); xdp_settings_read (win->settings, ns[0], "contrast", NULL, &error, "u", &uvalue2); if (!error) g_assert (uvalue2 == value); } value2 = xdp_settings_read_all_values (win->settings, ns, NULL, NULL); if (value2) { gsize count = g_variant_n_children (value2); g_autofree char *count_label = g_strdup_printf ("%lu", count); gtk_label_set_text (GTK_LABEL (win->settings_count), count_label); } } static void settings_changed (XdpSettings* settings, const gchar *namespace, const gchar *key, GVariant *value, gpointer data) { PortalTestWin *win = data; g_autofree char *label = g_strdup_printf ("chg %s %s", namespace, key); gtk_label_set_text (GTK_LABEL (win->settings_value), label); } static void portal_test_win_init (PortalTestWin *win) { const char *status; g_auto(GStrv) proxies = NULL; g_autofree char *proxy = NULL; g_autofree char *path = NULL; g_autofree char *filename = NULL; g_autoptr(GError) error = NULL; g_autoptr(GFile) file = NULL; g_autoptr(GFile) dst = NULL; g_autoptr(GFile) src = NULL; win->portal = xdp_portal_new (); gtk_widget_init_template (GTK_WIDGET (win)); path = g_build_filename (g_get_user_runtime_dir (), "flatpak-info", NULL); if (g_file_test (path, G_FILE_TEST_EXISTS)) status = "confined"; else status = "unconfined"; gtk_label_set_label (GTK_LABEL (win->sandbox_status), status); win->monitor = g_network_monitor_get_default (); gtk_label_set_label (GTK_LABEL (win->monitor_name), G_OBJECT_TYPE_NAME (win->monitor)); g_signal_connect_swapped (win->monitor, "notify", G_CALLBACK (update_network_status), win); update_network_status (win); win->resolver = g_proxy_resolver_get_default (); gtk_label_set_label (GTK_LABEL (win->resolver_name), G_OBJECT_TYPE_NAME (win->resolver)); proxies = g_proxy_resolver_lookup (win->resolver, "http://www.flatpak.org", NULL, &error); if (proxies == NULL) { g_print ("Failed to lookup proxies: %s\n", error->message); proxy = g_strdup (""); } else proxy = g_strjoinv (", ", proxies); gtk_label_set_label (GTK_LABEL (win->proxies), proxy); file = g_file_new_for_path ("/app/.updated"); win->update_monitor = g_file_monitor_file (file, 0, NULL, NULL); g_signal_connect (win->update_monitor, "changed", G_CALLBACK (update_monitor_changed), win); g_signal_connect (win->update_dialog, "response", G_CALLBACK (update_dialog_response), win); filename = g_build_filename (g_get_user_data_dir (), "test.txt", NULL); dst = g_file_new_for_path (filename); src = g_file_new_for_path (TEST_FILE_PATH); g_file_copy (src, dst, 0, NULL, NULL, NULL, NULL); xdp_portal_update_monitor_start (win->portal, 0, NULL, NULL, NULL); g_signal_connect (win->portal, "update-available", G_CALLBACK (update_available), win); g_signal_connect (win->update_dialog2, "response", G_CALLBACK (update_dialog2_response), win); win->settings = xdp_portal_get_settings (win->portal); g_signal_connect (win->settings, "changed", G_CALLBACK (settings_changed), win); } static void opened_uri (GObject *object, GAsyncResult *result, gpointer data) { XdpPortal *portal = XDP_PORTAL (object); PortalTestWin *win = data; g_autoptr(GError) error = NULL; gboolean open_dir; gboolean res; open_dir = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (win->open_local_dir)); if (open_dir) res = xdp_portal_open_directory_finish (portal, result, &error); else res = xdp_portal_open_uri_finish (portal, result, &error); if (!res) g_warning ("%s", error->message); } static void open_local (GtkWidget *button, PortalTestWin *win) { XdpParent *parent; g_autofree char *filename = NULL; g_autoptr(GFile) file = NULL; g_autofree char *uri = NULL; gboolean open_dir; XdpOpenUriFlags flags = XDP_OPEN_URI_FLAG_NONE; filename = g_build_filename (g_get_user_data_dir (), "test.txt", NULL); file = g_file_new_for_path (filename); uri = g_file_get_uri (file); g_message ("Opening '%s'", uri); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (win->open_local_ask))) flags |= XDP_OPEN_URI_FLAG_ASK; open_dir = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (win->open_local_dir)); parent = xdp_parent_new_gtk (GTK_WINDOW (win)); if (open_dir) xdp_portal_open_directory (win->portal, parent, uri, flags, NULL, opened_uri, win); else xdp_portal_open_uri (win->portal, parent, uri, flags, NULL, opened_uri, win); xdp_parent_free (parent); } static gboolean write_file_atomically (const char *path, GError **error) { return g_file_set_contents (path, "test", -1, error); } static gboolean write_file_gio (const char *path, GError **error) { g_autoptr(GFile) file = NULL; g_autoptr(GOutputStream) stream = NULL; file = g_file_new_for_path (path); stream = G_OUTPUT_STREAM (g_file_create (file, 0, NULL, error)); if (stream == NULL) return FALSE; if (g_output_stream_write (stream, "test", strlen ("test"), NULL, error) < 0) return FALSE; if (!g_output_stream_close (stream, NULL, error)) return FALSE; return TRUE; } static gboolean write_file_posix (const char *path, GError **error) { int fd; fd = creat (path, 0600); if (fd < 0) { g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errno), "creat failed"); return FALSE; } if (write (fd, "test", strlen ("test")) < 0) { g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "write failed"); return FALSE; } if (close (fd) < 0) { g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "close failed"); return FALSE; } return TRUE; } static void save_dialog (GtkWidget *button, PortalTestWin *win) { gint res; GtkFileChooserNative *dialog; GtkFileChooser *chooser; GtkWindow *parent; const char *options[] = { "current", "iso8859-15", "utf-16", NULL }; const char *labels[] = { "Current Locale (UTF-8)", "Western (ISO-8859-15)", "Unicode (UTF-16)", NULL, }; const char *encoding; const char *label; g_autofree char *text = NULL; const char *canonicalize; int i; parent = GTK_WINDOW (gtk_widget_get_toplevel (button)); dialog = gtk_file_chooser_native_new ("File Chooser Portal", parent, GTK_FILE_CHOOSER_ACTION_SAVE, "_Save", "_Cancel"); chooser = GTK_FILE_CHOOSER (dialog); #if GTK_CHECK_VERSION(3, 21, 4) gtk_file_chooser_add_choice (chooser, "encoding", "Character Encoding:", options, labels); gtk_file_chooser_set_choice (chooser, "encoding", "current"); gtk_file_chooser_add_choice (chooser, "canonicalize", "Canonicalize", NULL, NULL); gtk_file_chooser_set_choice (chooser, "canonicalize", "true"); #endif res = gtk_native_dialog_run (GTK_NATIVE_DIALOG (dialog)); g_message ("Saving file / Response: %d", res); if (res == GTK_RESPONSE_ACCEPT) { const char *method; char *filename; gboolean res = TRUE; g_autoptr(GError) error = NULL; method = gtk_combo_box_get_active_id (GTK_COMBO_BOX (win->save_how)); filename = gtk_file_chooser_get_filename (chooser); g_message ("Saving file: '%s'", filename); if (strcmp (method, "atomically") == 0) res = write_file_atomically (filename, &error); else if (strcmp (method, "posix") == 0) res = write_file_posix (filename, &error); else if (strcmp (method, "gio") == 0) res = write_file_gio (filename, &error); else g_message ("Not writing"); if (!res) g_message ("Failed: %s", error->message); g_free (filename); } #if GTK_CHECK_VERSION(3, 21, 4) encoding = gtk_file_chooser_get_choice (chooser, "encoding"); canonicalize = gtk_file_chooser_get_choice (chooser, "canonicalize"); #endif label = ""; for (i = 0; options[i]; i++) { if (g_strcmp0 (encoding, options[i]) == 0) label = labels[i]; } text = g_strdup_printf ("%s%s", label, g_str_equal (canonicalize, "true") ? " (canon)" : ""); gtk_label_set_label (GTK_LABEL (win->encoding), text); g_object_unref (dialog); } static void opened_directory (GObject *object, GAsyncResult *result, gpointer data) { XdpPortal *portal = XDP_PORTAL (object); g_autoptr(GError) error = NULL; gboolean res; res = xdp_portal_open_directory_finish (portal, result, &error); if (!res) g_warning ("%s", error->message); } static void open_directory (GtkWidget *button, PortalTestWin *win) { GtkFileChooser *file_chooser; g_autofree gchar *uri = NULL; XdpParent *parent; file_chooser = GTK_FILE_CHOOSER (win->file_chooser_button); uri = gtk_file_chooser_get_uri (file_chooser); if (!uri) return; g_message ("Opening '%s'", uri); parent = xdp_parent_new_gtk (GTK_WINDOW (win)); xdp_portal_open_directory (win->portal, parent, uri, XDP_OPEN_URI_FLAG_NONE, NULL, opened_directory, win); xdp_parent_free (parent); } static void taken (GObject *source, GAsyncResult *result, gpointer data) { PortalTestWin *win = data; g_autofree char *uri = NULL; g_autoptr(GError) error = NULL; uri = xdp_portal_take_screenshot_finish (win->portal, result, &error); if (uri != NULL) { g_autofree char *path = NULL; g_autoptr(GdkPixbuf) pixbuf = NULL; g_autoptr(GError) error = NULL; path = g_filename_from_uri (uri, NULL, NULL); pixbuf = gdk_pixbuf_new_from_file_at_scale (path, 60, 40, TRUE, &error); if (pixbuf == NULL) g_warning ("Failed to load screenshot from %s: %s", uri, error->message); else gtk_image_set_from_pixbuf (GTK_IMAGE (win->image), pixbuf); } else g_warning ("Failed to load screenshot: %s", error->message); } static void take_screenshot (GtkButton *button, PortalTestWin *win) { XdpParent *parent; XdpScreenshotFlags flags = XDP_SCREENSHOT_FLAG_NONE; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (win->interactive))) flags = XDP_SCREENSHOT_FLAG_INTERACTIVE; parent = xdp_parent_new_gtk (GTK_WINDOW (win)); xdp_portal_take_screenshot (win->portal, parent, flags, NULL, taken, win); xdp_parent_free (parent); } static void on_selection_owner_changed (XdpSession *session, GStrv mime_types, gboolean session_is_owner, PortalTestWin *win) { update_clipboard (win); } static void on_selection_transfer (XdpSession *session, const char *mime_type, unsigned int serial, PortalTestWin *win) { int fd; g_autoptr(GOutputStream) output_stream = NULL; g_autoptr(GError) error = NULL; const char *text; fd = xdp_session_selection_write (session, serial); if (fd < 0) return; text = gtk_entry_get_text (GTK_ENTRY (win->clipboard_entry)); output_stream = g_unix_output_stream_new (g_steal_fd (&fd), TRUE); if (!g_output_stream_write_all (output_stream, text, strlen (text), NULL, NULL, &error)) g_warning ("Failed to write clipboard content: %s", error->message); g_clear_object (&output_stream); xdp_session_selection_write_done (session, serial, !error); } static void update_clipboard (PortalTestWin *win) { if (win->session && xdp_session_is_clipboard_enabled (win->session)) { const char **mime_types; mime_types = xdp_session_get_selection_mime_types (win->session); if (!xdp_session_is_selection_owned_by_session (win->session) && mime_types && g_strv_contains (mime_types, "text/plain")) gtk_widget_set_sensitive (win->clipboard_paste, TRUE); else gtk_widget_set_sensitive (win->clipboard_paste, FALSE); gtk_widget_set_sensitive (win->clipboard_copy, TRUE); if (!win->selection_owner_changed) { win->selection_owner_changed = g_signal_connect (win->session, "selection-owner-changed", G_CALLBACK (on_selection_owner_changed), win); win->selection_transfer_handler_id = g_signal_connect (win->session, "selection-transfer", G_CALLBACK (on_selection_transfer), win); } } else { gtk_widget_set_sensitive (win->clipboard_copy, FALSE); gtk_widget_set_sensitive (win->clipboard_paste, FALSE); if (win->session) { g_clear_signal_handler (&win->selection_owner_changed, win->session); g_clear_signal_handler (&win->selection_transfer_handler_id, win->session); } else { win->selection_transfer_handler_id = 0; win->selection_owner_changed = 0; } } } static void inputcapture_session_started (GObject *source, GAsyncResult *result, gpointer data) { XdpInputCaptureSession *ic = XDP_INPUT_CAPTURE_SESSION (source); PortalTestWin *win = data; g_autoptr(GError) error = NULL; GList *zones; g_autoptr (GString) s = NULL; if (!xdp_input_capture_session_start_finish (ic, result, &error)) { g_warning ("Failed to start inputcapture session: %s", error->message); return; } zones = xdp_input_capture_session_get_zones (ic); s = g_string_new (""); for (GList *elem = g_list_first (zones); elem; elem = g_list_next (elem)) { XdpInputCaptureZone *zone = elem->data; guint w, h; gint x, y; g_object_get (zone, "width", &w, "height", &h, "x", &x, "y", &y, NULL); g_string_append_printf (s, "%ux%u@%d,%d ", w, h, x, y); } gtk_label_set_label (GTK_LABEL (win->inputcapture_label), s->str); update_clipboard (win); } static void inputcapture_session_created2 (GObject *source, GAsyncResult *result, gpointer data) { XdpPortal *portal = XDP_PORTAL (source); PortalTestWin *win = data; g_autoptr(GError) error = NULL; g_autoptr (GString) s = NULL; XdpInputCaptureSession *ic; ic = xdp_portal_create_input_capture_session2_finish (portal, result, &error); if (ic == NULL) { g_warning ("Failed to create inputcapture session: %s", error->message); return; } win->session = xdp_input_capture_session_get_session (ic); win->input_capture_session = ic; xdp_session_request_clipboard (win->session); xdp_input_capture_session_start (ic, NULL, XDP_INPUT_CAPABILITY_POINTER | XDP_INPUT_CAPABILITY_KEYBOARD, NULL, inputcapture_session_started, win); } static void inputcapture_session_created (GObject *source, GAsyncResult *result, gpointer data) { XdpPortal *portal = XDP_PORTAL (source); PortalTestWin *win = data; g_autoptr(GError) error = NULL; GList *zones; g_autoptr (GString) s = NULL; XdpInputCaptureSession *ic; ic = xdp_portal_create_input_capture_session_finish (portal, result, &error); if (ic == NULL) { g_warning ("Failed to create inputcapture session: %s", error->message); return; } win->session = xdp_input_capture_session_get_session (ic); win->input_capture_session = ic; zones = xdp_input_capture_session_get_zones (ic); s = g_string_new (""); for (GList *elem = g_list_first (zones); elem; elem = g_list_next (elem)) { XdpInputCaptureZone *zone = elem->data; guint w, h; gint x, y; g_object_get (zone, "width", &w, "height", &h, "x", &x, "y", &y, NULL); g_string_append_printf (s, "%ux%u@%d,%d ", w, h, x, y); } gtk_label_set_label (GTK_LABEL (win->inputcapture_label), s->str); } static void start_input_capture (PortalTestWin *win) { g_clear_object (&win->session); update_clipboard (win); if (xdp_portal_get_input_capture_version_sync (win->portal, NULL, NULL) > 1) { xdp_portal_create_input_capture_session2 (win->portal, NULL, inputcapture_session_created2, win); } else { xdp_portal_create_input_capture_session (win->portal, NULL, XDP_INPUT_CAPABILITY_POINTER | XDP_INPUT_CAPABILITY_KEYBOARD, NULL, inputcapture_session_created, win); } } static void stop_input_capture (PortalTestWin *win) { if (win->session != NULL) { xdp_session_close (win->session); if (xdp_session_get_session_type (win->session) == XDP_SESSION_INPUT_CAPTURE) { g_clear_object (&win->input_capture_session); win->session = NULL; } else { g_clear_object (&win->session); } update_clipboard (win); gtk_label_set_label (GTK_LABEL (win->inputcapture_label), ""); } } static void capture_input (GtkButton *button, PortalTestWin *win) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) start_input_capture (win); else stop_input_capture (win); } static void capture_input_release (GtkButton *button, PortalTestWin *win) { /* FIXME */ } static void capture_input_toggle_enable (GtkButton *button, PortalTestWin *win) { if (!win->input_capture_session) return; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) xdp_input_capture_session_enable (win->input_capture_session); else xdp_input_capture_session_disable (win->input_capture_session); } static void session_started (GObject *source, GAsyncResult *result, gpointer data) { XdpSession *session = (XdpSession*) source; PortalTestWin *win = data; g_autoptr(GError) error = NULL; guint id; g_autoptr(GVariantIter) iter = NULL; GVariant *props; g_autoptr(GStrvBuilder) builder = g_strv_builder_new (); g_auto(GStrv) strv = NULL; g_autofree char *s = NULL; XdpDeviceType device_types; if (!xdp_session_start_finish (session, result, &error)) { g_warning ("Failed to start session: %s", error->message); g_clear_object (&win->session); update_clipboard (win); if (xdp_session_get_session_type (session) == XDP_SESSION_SCREENCAST) { gtk_label_set_label (GTK_LABEL (win->screencast_label), ""); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (win->screencast_toggle), FALSE); } else if (xdp_session_get_session_type (session) == XDP_SESSION_REMOTE_DESKTOP) { gtk_label_set_label (GTK_LABEL (win->remotedesktop_label), ""); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (win->remotedesktop_toggle), FALSE); } return; } update_clipboard (win); iter = g_variant_iter_new (xdp_session_get_streams (session)); while (g_variant_iter_next (iter, "(u@a{sv})", &id, &props)) { int x, y, w, h; g_variant_lookup (props, "position", "(ii)", &x, &y); g_variant_lookup (props, "size", "(ii)", &w, &h); g_strv_builder_take (builder, g_strdup_printf ("Stream %d: %dx%d @ %d,%d", id, w, h, x, y)); g_variant_unref (props); } device_types = xdp_session_get_devices (session); if (device_types) { g_autoptr(GStrvBuilder) b = g_strv_builder_new (); g_auto(GStrv) devices = NULL; g_autofree char* devices_s = NULL; if (device_types & XDP_DEVICE_KEYBOARD) g_strv_builder_add (b, "keyboard"); if (device_types & XDP_DEVICE_POINTER) g_strv_builder_add (b, "pointer"); if (device_types & XDP_DEVICE_TOUCHSCREEN) g_strv_builder_add (b, "touchscreen"); devices = g_strv_builder_end (b); devices_s = g_strjoinv (", ", devices); g_strv_builder_take (builder, g_strdup_printf("Devices: %s", devices_s)); } g_strv_builder_take (builder, g_strdup_printf ("Clipboard: %s", xdp_session_is_clipboard_enabled (session) ? "yes" : "no")); strv = g_strv_builder_end (builder); s = g_strjoinv (", ", strv); if (xdp_session_get_session_type (session) == XDP_SESSION_SCREENCAST) gtk_label_set_label (GTK_LABEL (win->screencast_label), s); else if (xdp_session_get_session_type (session) == XDP_SESSION_REMOTE_DESKTOP) gtk_label_set_label (GTK_LABEL (win->remotedesktop_label), s); } static void screencast_session_created (GObject *source, GAsyncResult *result, gpointer data) { XdpPortal *portal = XDP_PORTAL (source); PortalTestWin *win = data; g_autoptr(GError) error = NULL; XdpParent *parent = NULL; win->session = xdp_portal_create_screencast_session_finish (portal, result, &error); if (win->session == NULL) { g_warning ("Failed to create screencast session: %s", error->message); return; } parent = xdp_parent_new_gtk (GTK_WINDOW (win)); xdp_session_start (win->session, parent, NULL, session_started, win); xdp_parent_free (parent); } static void start_screencast (PortalTestWin *win) { g_clear_object (&win->session); update_clipboard (win); xdp_portal_create_screencast_session (win->portal, XDP_OUTPUT_MONITOR | XDP_OUTPUT_WINDOW, XDP_SCREENCAST_FLAG_NONE, XDP_CURSOR_MODE_HIDDEN, XDP_PERSIST_MODE_NONE, NULL, NULL, screencast_session_created, win); } static void stop_screencast (PortalTestWin *win) { if (win->session != NULL) { xdp_session_close (win->session); g_clear_object (&win->session); update_clipboard (win); gtk_label_set_label (GTK_LABEL (win->screencast_label), ""); } } static void screencast_toggled (GtkToggleButton *button, PortalTestWin *win) { if (gtk_toggle_button_get_active (button)) start_screencast (win); else stop_screencast (win); } static void remotedesktop_session_created (GObject *source, GAsyncResult *result, gpointer data) { XdpPortal *portal = XDP_PORTAL (source); PortalTestWin *win = data; g_autoptr(GError) error = NULL; XdpParent *parent = NULL; win->session = xdp_portal_create_remote_desktop_session_finish (portal, result, &error); if (win->session == NULL) { g_warning ("Failed to create remotedesktop session: %s", error->message); return; } xdp_session_request_clipboard (win->session); parent = xdp_parent_new_gtk (GTK_WINDOW (win)); xdp_session_start (win->session, parent, NULL, session_started, win); xdp_parent_free (parent); } static void start_remotedesktop (PortalTestWin *win) { g_clear_object (&win->session); update_clipboard (win); xdp_portal_create_remote_desktop_session (win->portal, (XDP_DEVICE_KEYBOARD | XDP_DEVICE_POINTER | XDP_DEVICE_TOUCHSCREEN), XDP_OUTPUT_MONITOR | XDP_OUTPUT_WINDOW, XDP_REMOTE_DESKTOP_FLAG_NONE, XDP_CURSOR_MODE_HIDDEN, NULL, remotedesktop_session_created, win); } static void stop_remotedesktop (PortalTestWin *win) { if (win->session != NULL) { xdp_session_close (win->session); g_clear_object (&win->session); update_clipboard (win); gtk_label_set_label (GTK_LABEL (win->remotedesktop_label), ""); } } static void remotedesktop_toggled (GtkToggleButton *button, PortalTestWin *win) { if (gtk_toggle_button_get_active (button)) start_remotedesktop (win); else stop_remotedesktop (win); } static void paste_clicked (GtkButton *button, PortalTestWin *win) { int fd; g_autoptr(GInputStream) input_stream = NULL; g_autoptr(GError) error = NULL; char clipboard_content[1024] = {}; fd = xdp_session_selection_read (win->session, "text/plain"); if (fd < 0) return; input_stream = g_unix_input_stream_new (g_steal_fd (&fd), TRUE); if (!g_input_stream_read_all (input_stream, clipboard_content, sizeof (clipboard_content) - 1, NULL, NULL, &error)) { g_warning ("Failed to read clipboard content: %s", error->message); return; } gtk_label_set_label (GTK_LABEL (win->clipboard_label), clipboard_content); } static void copy_clicked (GtkButton *button, PortalTestWin *win) { const char *mime_types[] = { "text/plain", NULL, }; xdp_session_set_selection (win->session, mime_types); } static void account_response (GObject *source, GAsyncResult *result, gpointer data) { PortalTestWin *win = data; g_autoptr(GVariant) ret = NULL; g_autoptr(GError) error = NULL; ret = xdp_portal_get_user_information_finish (win->portal, result, &error); if (ret) { const char *id; const char *name; const char *uri; g_autofree char *path = NULL; g_variant_lookup (ret, "id", "&s", &id); g_variant_lookup (ret, "name", "&s", &name); g_variant_lookup (ret, "image", "&s", &uri); gtk_label_set_label (GTK_LABEL (win->username), id); gtk_label_set_label (GTK_LABEL (win->realname), name); if (uri && uri[0]) { g_autoptr(GdkPixbuf) pixbuf = NULL; path = g_filename_from_uri (uri, NULL, NULL); pixbuf = gdk_pixbuf_new_from_file_at_scale (path, 60, 40, TRUE, &error); if (error) g_warning ("Failed to load photo %s: %s", path, error->message); else gtk_image_set_from_pixbuf (GTK_IMAGE (win->avatar), pixbuf); } } else if (error) g_message ("Account error: %s", error->message); else g_message ("Account canceled"); } static void get_user_information (PortalTestWin *win) { XdpParent *parent; parent = xdp_parent_new_gtk (GTK_WINDOW (win)); xdp_portal_get_user_information (win->portal, parent, "Allows portal-test to test the Account portal.", XDP_USER_INFORMATION_FLAG_NONE, NULL, account_response, win); xdp_parent_free (parent); } static void compose_email_called (GObject *source, GAsyncResult *result, gpointer data) { PortalTestWin *win = data; g_autoptr(GError) error = NULL; if (!xdp_portal_compose_email_finish (win->portal, result, &error)) { g_warning ("Email error: %s", error->message); return; } g_print ("Email sent\n"); } static void compose_email (PortalTestWin *win) { XdpParent *parent; g_autofree char *filename = NULL; const char *addresses[2]; const char *cc[3]; const char *attachments[2]; filename = g_build_filename (g_get_user_data_dir (), "test.txt", NULL); attachments[0] = filename; attachments[1] = NULL; addresses[0] = "recipes-list@gnome.org"; addresses[1] = NULL; cc[0] = "mclasen@redhat.com"; cc[1] = "dead@email.com"; cc[2] = NULL; parent = xdp_parent_new_gtk (GTK_WINDOW (win)); xdp_portal_compose_email (win->portal, parent, addresses, cc, NULL, "Test subject", "Test body", attachments, XDP_EMAIL_FLAG_NONE, NULL, compose_email_called, win); xdp_parent_free (parent); } static void request_background_called (GObject *source, GAsyncResult *result, gpointer data) { PortalTestWin *win = data; g_autoptr(GError) error = NULL; gboolean ret = xdp_portal_request_background_finish (win->portal, result, &error); if (!ret) { g_warning ("Background request failed: %s", error ? error->message : "Unknown error"); return; } g_message ("Background request successful!"); } static void request_background (PortalTestWin *win) { XdpParent *parent; g_autoptr(GPtrArray) commandline = g_ptr_array_new_with_free_func (g_free); g_ptr_array_add (commandline, g_strdup ("/bin/true")); parent = xdp_parent_new_gtk (GTK_WINDOW (win)); xdp_portal_request_background (win->portal, parent, "Test reason", commandline, XDP_BACKGROUND_FLAG_AUTOSTART, NULL, request_background_called, win); xdp_parent_free (parent); } static void notify_me (PortalTestWin *win) { GVariantBuilder button; GVariantBuilder buttons; GVariantBuilder notification; gtk_widget_hide (win->ack_image); g_variant_builder_init (&button, G_VARIANT_TYPE_VARDICT); g_variant_builder_add (&button, "{sv}", "label", g_variant_new_string ("Yup")); g_variant_builder_add (&button, "{sv}", "action", g_variant_new_string ("app.ack")); g_variant_builder_init (&buttons, G_VARIANT_TYPE ("aa{sv}")); g_variant_builder_add (&buttons, "a{sv}", &button); g_variant_builder_init (¬ification, G_VARIANT_TYPE_VARDICT); g_variant_builder_add (¬ification, "{sv}", "title", g_variant_new_string ("Notify me")); g_variant_builder_add (¬ification, "{sv}", "body", g_variant_new_string ("Really important information would ordinarily appear here")); g_variant_builder_add (¬ification, "{sv}", "buttons", g_variant_builder_end (&buttons)); xdp_portal_add_notification (win->portal, "notification", g_variant_builder_end (¬ification), XDP_NOTIFICATION_FLAG_NONE, NULL, NULL, NULL); } void portal_test_win_ack (PortalTestWin *win) { gtk_widget_show (win->ack_image); } static GList *active_prints = NULL; typedef struct { char *text; PangoLayout *layout; GList *page_breaks; char *font; } PrintData; static void status_changed_cb (GtkPrintOperation *op, gpointer user_data) { if (gtk_print_operation_is_finished (op)) { active_prints = g_list_remove (active_prints, op); g_object_unref (op); } } static void begin_print (GtkPrintOperation *operation, GtkPrintContext *context, PrintData *print_data) { PangoFontDescription *desc; PangoLayoutLine *layout_line; double width, height; double page_height; GList *page_breaks; int num_lines; int line; width = gtk_print_context_get_width (context); height = gtk_print_context_get_height (context); print_data->layout = gtk_print_context_create_pango_layout (context); desc = pango_font_description_from_string (print_data->font); pango_layout_set_font_description (print_data->layout, desc); pango_font_description_free (desc); pango_layout_set_width (print_data->layout, width * PANGO_SCALE); pango_layout_set_text (print_data->layout, print_data->text, -1); num_lines = pango_layout_get_line_count (print_data->layout); page_breaks = NULL; page_height = 0; for (line = 0; line < num_lines; line++) { PangoRectangle ink_rect, logical_rect; double line_height; layout_line = pango_layout_get_line (print_data->layout, line); pango_layout_line_get_extents (layout_line, &ink_rect, &logical_rect); line_height = logical_rect.height / 1024.0; if (page_height + line_height > height) { page_breaks = g_list_prepend (page_breaks, GINT_TO_POINTER (line)); page_height = 0; } page_height += line_height; } page_breaks = g_list_reverse (page_breaks); gtk_print_operation_set_n_pages (operation, g_list_length (page_breaks) + 1); print_data->page_breaks = page_breaks; } static void draw_page (GtkPrintOperation *operation, GtkPrintContext *context, int page_nr, PrintData *print_data) { cairo_t *cr; GList *pagebreak; int start, end, i; PangoLayoutIter *iter; double start_pos; if (page_nr == 0) start = 0; else { pagebreak = g_list_nth (print_data->page_breaks, page_nr - 1); start = GPOINTER_TO_INT (pagebreak->data); } pagebreak = g_list_nth (print_data->page_breaks, page_nr); if (pagebreak == NULL) end = pango_layout_get_line_count (print_data->layout); else end = GPOINTER_TO_INT (pagebreak->data); cr = gtk_print_context_get_cairo_context (context); cairo_set_source_rgb (cr, 0, 0, 0); i = 0; start_pos = 0; iter = pango_layout_get_iter (print_data->layout); do { PangoRectangle logical_rect; PangoLayoutLine *line; int baseline; if (i >= start) { line = pango_layout_iter_get_line (iter); pango_layout_iter_get_line_extents (iter, NULL, &logical_rect); baseline = pango_layout_iter_get_baseline (iter); if (i == start) start_pos = logical_rect.y / 1024.0; cairo_move_to (cr, logical_rect.x / 1024.0, baseline / 1024.0 - start_pos); pango_cairo_show_layout_line (cr, line); } i++; } while (i < end && pango_layout_iter_next_line (iter)); pango_layout_iter_free (iter); } static void end_print (GtkPrintOperation *op, GtkPrintContext *context, PrintData *print_data) { g_list_free (print_data->page_breaks); print_data->page_breaks = NULL; g_object_unref (print_data->layout); print_data->layout = NULL; } static void print_done (GtkPrintOperation *op, GtkPrintOperationResult res, PrintData *print_data) { GError *error = NULL; if (res == GTK_PRINT_OPERATION_RESULT_ERROR) { GtkWidget *error_dialog; gtk_print_operation_get_error (op, &error); error_dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Error printing file:\n%s", error ? error->message : "no details"); g_signal_connect (error_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (error_dialog); } g_free (print_data->text); g_free (print_data->font); g_free (print_data); if (!gtk_print_operation_is_finished (op)) { g_object_ref (op); active_prints = g_list_append (active_prints, op); /* This ref is unref:ed when we get the final state change */ g_signal_connect (op, "status-changed", G_CALLBACK (status_changed_cb), NULL); } } static char * get_text (void) { char *text; g_autofree char* test_file_path = file_path_in_source_dir ("portal-test-win.c"); g_autoptr(GError) error = NULL; if (!g_file_get_contents (test_file_path, &text, NULL, &error)) { g_warning ("Failed to load print text: %s", error->message); text = g_strdup (error->message); } return text; } static void print_cb (GtkButton *button, PortalTestWin *win) { GtkPrintOperation *print; PrintData *print_data; print_data = g_new0 (PrintData, 1); print_data->text = get_text (); print_data->font = g_strdup ("Sans 12"); print = gtk_print_operation_new (); g_signal_connect (print, "begin-print", G_CALLBACK (begin_print), print_data); g_signal_connect (print, "end-print", G_CALLBACK (end_print), print_data); g_signal_connect (print, "draw-page", G_CALLBACK (draw_page), print_data); g_signal_connect (print, "done", G_CALLBACK (print_done), print_data); //gtk_print_operation_set_allow_async (print, TRUE); gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (win), NULL); g_object_unref (print); } static void inhibit_finished (GObject *source, GAsyncResult *result, gpointer data) { g_autoptr(GError) error = NULL; PortalTestWin *win = data; win->inhibit_cookie = xdp_portal_session_inhibit_finish (XDP_PORTAL (source), result, &error); } static void inhibit_changed (GtkToggleButton *button, PortalTestWin *win) { GtkApplicationInhibitFlags flags = 0; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (win->inhibit_logout))) flags |= GTK_APPLICATION_INHIBIT_LOGOUT; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (win->inhibit_switch))) flags |= GTK_APPLICATION_INHIBIT_SWITCH; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (win->inhibit_suspend))) flags |= GTK_APPLICATION_INHIBIT_SUSPEND; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (win->inhibit_idle))) flags |= GTK_APPLICATION_INHIBIT_IDLE; if (win->inhibit_flags == flags) return; if (win->inhibit_cookie != 0) { xdp_portal_session_uninhibit (win->portal, win->inhibit_cookie); win->inhibit_cookie = 0; } win->inhibit_flags = flags; if (win->inhibit_flags != 0) { XdpParent *parent; parent = xdp_parent_new_gtk (GTK_WINDOW (win)); xdp_portal_session_inhibit (win->portal, parent, "Portal Testing", (XdpInhibitFlags)win->inhibit_flags, NULL, inhibit_finished, win); xdp_parent_free (parent); } } static gboolean pipeline_stop (GstElement *pipeline) { gst_element_set_state (pipeline, GST_STATE_NULL); g_object_unref (pipeline); return FALSE; } static gboolean watch_func (GstBus *bus, GstMessage *message, gpointer data) { GstElement *pipeline = data; g_print ("message %d\n", GST_MESSAGE_TYPE (message)); if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR) { g_autoptr(GError) err = NULL; gst_message_parse_error (message, &err, NULL); g_print ("ERROR: %s\n", err->message); gst_element_set_state (pipeline, GST_STATE_NULL); g_object_unref (pipeline); g_object_unref (bus); return FALSE; } else if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_STATE_CHANGED) { GstStateChangeReturn change; GstState state; GstState pending; change = gst_element_get_state (pipeline, &state, &pending, GST_MSECOND); if (change == GST_STATE_CHANGE_SUCCESS) g_print ("Pipeline state now %d\n", state); else if (change == GST_STATE_CHANGE_ASYNC) g_print ("Pipeline state now %d, pending %d\n", state, pending); else g_print ("Pipeline state change failed, now %d\n", state); if (state == GST_STATE_PLAYING) { g_timeout_add (500, (GSourceFunc) pipeline_stop, pipeline); g_object_unref (bus); return FALSE; } } return TRUE; } static void play_sound (gdouble frequency) { GstElement *source, *sink; GstElement *pipeline; GstBus *bus; pipeline = gst_pipeline_new ("note"); source = gst_element_factory_make ("audiotestsrc", "source"); sink = gst_element_factory_make ("autoaudiosink", "output"); g_object_set (source, "freq", frequency, NULL); gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL); gst_element_link (source, sink); bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); gst_bus_add_watch (bus, watch_func, pipeline); g_print ("Set pipeline state to playing\n"); gst_element_set_state (pipeline, GST_STATE_PLAYING); } static void play_clicked (GtkButton *button, PortalTestWin *win) { play_sound (440.0); } static void set_wallpaper_called (GObject *source, GAsyncResult *result, gpointer data) { PortalTestWin *win = data; g_autoptr(GError) error = NULL; gboolean ret = xdp_portal_set_wallpaper_finish (win->portal, result, &error); if (!ret) { g_warning ("Wallpaper request failed: %s", error ? error->message : "Unknown error"); return; } g_message ("Wallpaper request successful!"); } static void set_wallpaper (PortalTestWin *win) { XdpParent *parent; // const char *uri = "https://gitlab.gnome.org/GNOME/gtk/raw/master/demos/gtk-demo/portland-rose.jpg"; const char *uri = "file:///usr/share/backgrounds/gnome/adwaita-morning.jpg"; parent = xdp_parent_new_gtk (GTK_WINDOW (win)); xdp_portal_set_wallpaper (win->portal, parent, uri, XDP_WALLPAPER_FLAG_BACKGROUND | XDP_WALLPAPER_FLAG_PREVIEW, NULL, set_wallpaper_called, win); xdp_parent_free (parent); } static void portal_test_win_class_init (PortalTestWinClass *class) { GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class); gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/portal-test/portal-test-win.ui"); gtk_widget_class_bind_template_callback (widget_class, save_dialog); gtk_widget_class_bind_template_callback (widget_class, open_directory); gtk_widget_class_bind_template_callback (widget_class, open_local); gtk_widget_class_bind_template_callback (widget_class, take_screenshot); gtk_widget_class_bind_template_callback (widget_class, capture_input); gtk_widget_class_bind_template_callback (widget_class, capture_input_release); gtk_widget_class_bind_template_callback (widget_class, capture_input_toggle_enable); gtk_widget_class_bind_template_callback (widget_class, screencast_toggled); gtk_widget_class_bind_template_callback (widget_class, remotedesktop_toggled); gtk_widget_class_bind_template_callback (widget_class, paste_clicked); gtk_widget_class_bind_template_callback (widget_class, copy_clicked); gtk_widget_class_bind_template_callback (widget_class, notify_me); gtk_widget_class_bind_template_callback (widget_class, print_cb); gtk_widget_class_bind_template_callback (widget_class, inhibit_changed); gtk_widget_class_bind_template_callback (widget_class, play_clicked); gtk_widget_class_bind_template_callback (widget_class, get_user_information); gtk_widget_class_bind_template_callback (widget_class, compose_email); gtk_widget_class_bind_template_callback (widget_class, reload_settings); gtk_widget_class_bind_template_callback (widget_class, request_background); gtk_widget_class_bind_template_callback (widget_class, set_wallpaper); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, sandbox_status); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, network_status); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, monitor_name); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, proxies); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, resolver_name); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, image); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, interactive); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, encoding); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, ack_image); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, inhibit_idle); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, inhibit_logout); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, inhibit_suspend); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, inhibit_switch); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, inputcapture_label); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, inputcapture_toggle); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, username); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, realname); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, avatar); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, save_how); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, settings_value); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, settings_count); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, screencast_label); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, screencast_toggle); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, remotedesktop_label); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, remotedesktop_toggle); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, clipboard_label); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, clipboard_copy); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, clipboard_paste); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, clipboard_entry); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, update_dialog); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, update_dialog2); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, update_progressbar); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, update_label); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, ok2); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, open_local_dir); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, open_local_ask); gtk_widget_class_bind_template_child (widget_class, PortalTestWin, file_chooser_button); } GtkApplicationWindow * portal_test_win_new (PortalTestApp *app) { return g_object_new (portal_test_win_get_type (), "application", app, NULL); }