1 /*
2 * GTK UI -- clipboard support
3 *
4 * Copyright (C) 2021 Gerd Hoffmann <kraxel@redhat.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "qemu/osdep.h"
22 #include "qemu/error-report.h"
23 #include "qemu/main-loop.h"
24
25 #include "ui/gtk.h"
26
gd_find_selection(GtkDisplayState * gd,GtkClipboard * clipboard)27 static QemuClipboardSelection gd_find_selection(GtkDisplayState *gd,
28 GtkClipboard *clipboard)
29 {
30 QemuClipboardSelection s;
31
32 for (s = 0; s < QEMU_CLIPBOARD_SELECTION__COUNT; s++) {
33 if (gd->gtkcb[s] == clipboard) {
34 return s;
35 }
36 }
37 return QEMU_CLIPBOARD_SELECTION_CLIPBOARD;
38 }
39
gd_clipboard_get_data(GtkClipboard * clipboard,GtkSelectionData * selection_data,guint selection_info,gpointer data)40 static void gd_clipboard_get_data(GtkClipboard *clipboard,
41 GtkSelectionData *selection_data,
42 guint selection_info,
43 gpointer data)
44 {
45 GtkDisplayState *gd = data;
46 QemuClipboardSelection s = gd_find_selection(gd, clipboard);
47 QemuClipboardType type = QEMU_CLIPBOARD_TYPE_TEXT;
48 g_autoptr(QemuClipboardInfo) info = NULL;
49
50 info = qemu_clipboard_info_ref(qemu_clipboard_info(s));
51
52 qemu_clipboard_request(info, type);
53 while (info == qemu_clipboard_info(s) &&
54 info->types[type].available &&
55 info->types[type].data == NULL) {
56 main_loop_wait(false);
57 }
58
59 if (info == qemu_clipboard_info(s) && gd->cbowner[s]) {
60 gtk_selection_data_set_text(selection_data,
61 info->types[type].data,
62 info->types[type].size);
63 } else {
64 /* clipboard owner changed while waiting for the data */
65 }
66 }
67
gd_clipboard_clear(GtkClipboard * clipboard,gpointer data)68 static void gd_clipboard_clear(GtkClipboard *clipboard,
69 gpointer data)
70 {
71 GtkDisplayState *gd = data;
72 QemuClipboardSelection s = gd_find_selection(gd, clipboard);
73
74 gd->cbowner[s] = false;
75 }
76
gd_clipboard_update_info(GtkDisplayState * gd,QemuClipboardInfo * info)77 static void gd_clipboard_update_info(GtkDisplayState *gd,
78 QemuClipboardInfo *info)
79 {
80 QemuClipboardSelection s = info->selection;
81 bool self_update = info->owner == &gd->cbpeer;
82
83 if (info != qemu_clipboard_info(s)) {
84 gd->cbpending[s] = 0;
85 if (!self_update) {
86 g_autoptr(GtkTargetList) list = NULL;
87 GtkTargetEntry *targets;
88 gint n_targets;
89
90 list = gtk_target_list_new(NULL, 0);
91 if (info->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
92 gtk_target_list_add_text_targets(list, 0);
93 }
94 targets = gtk_target_table_new_from_list(list, &n_targets);
95
96 gtk_clipboard_clear(gd->gtkcb[s]);
97 if (targets) {
98 gd->cbowner[s] = true;
99 if (!gtk_clipboard_set_with_data(gd->gtkcb[s],
100 targets, n_targets,
101 gd_clipboard_get_data,
102 gd_clipboard_clear,
103 gd)) {
104 warn_report("Failed to set GTK clipboard");
105 }
106
107 gtk_target_table_free(targets, n_targets);
108 }
109 }
110 return;
111 }
112
113 if (self_update) {
114 return;
115 }
116
117 /*
118 * Clipboard got updated, with data probably. No action here, we
119 * are waiting for updates in gd_clipboard_get_data().
120 */
121 }
122
gd_clipboard_notify(Notifier * notifier,void * data)123 static void gd_clipboard_notify(Notifier *notifier, void *data)
124 {
125 GtkDisplayState *gd =
126 container_of(notifier, GtkDisplayState, cbpeer.notifier);
127 QemuClipboardNotify *notify = data;
128
129 switch (notify->type) {
130 case QEMU_CLIPBOARD_UPDATE_INFO:
131 gd_clipboard_update_info(gd, notify->info);
132 return;
133 case QEMU_CLIPBOARD_RESET_SERIAL:
134 /* ignore */
135 return;
136 }
137 }
138
gd_clipboard_request(QemuClipboardInfo * info,QemuClipboardType type)139 static void gd_clipboard_request(QemuClipboardInfo *info,
140 QemuClipboardType type)
141 {
142 GtkDisplayState *gd = container_of(info->owner, GtkDisplayState, cbpeer);
143 char *text;
144
145 switch (type) {
146 case QEMU_CLIPBOARD_TYPE_TEXT:
147 text = gtk_clipboard_wait_for_text(gd->gtkcb[info->selection]);
148 if (text) {
149 qemu_clipboard_set_data(&gd->cbpeer, info, type,
150 strlen(text), text, true);
151 g_free(text);
152 }
153 break;
154 default:
155 break;
156 }
157 }
158
gd_owner_change(GtkClipboard * clipboard,GdkEvent * event,gpointer data)159 static void gd_owner_change(GtkClipboard *clipboard,
160 GdkEvent *event,
161 gpointer data)
162 {
163 GtkDisplayState *gd = data;
164 QemuClipboardSelection s = gd_find_selection(gd, clipboard);
165 QemuClipboardInfo *info;
166
167 if (gd->cbowner[s]) {
168 /* ignore notifications about our own grabs */
169 return;
170 }
171
172
173 switch (event->owner_change.reason) {
174 case GDK_OWNER_CHANGE_NEW_OWNER:
175 info = qemu_clipboard_info_new(&gd->cbpeer, s);
176 if (gtk_clipboard_wait_is_text_available(clipboard)) {
177 info->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true;
178 }
179
180 qemu_clipboard_update(info);
181 qemu_clipboard_info_unref(info);
182 break;
183 default:
184 qemu_clipboard_peer_release(&gd->cbpeer, s);
185 gd->cbowner[s] = false;
186 break;
187 }
188 }
189
gd_clipboard_init(GtkDisplayState * gd)190 void gd_clipboard_init(GtkDisplayState *gd)
191 {
192 gd->cbpeer.name = "gtk";
193 gd->cbpeer.notifier.notify = gd_clipboard_notify;
194 gd->cbpeer.request = gd_clipboard_request;
195 qemu_clipboard_peer_register(&gd->cbpeer);
196
197 gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD] =
198 gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
199 gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY] =
200 gtk_clipboard_get(GDK_SELECTION_PRIMARY);
201 gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY] =
202 gtk_clipboard_get(GDK_SELECTION_SECONDARY);
203
204 g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD],
205 "owner-change", G_CALLBACK(gd_owner_change), gd);
206 g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY],
207 "owner-change", G_CALLBACK(gd_owner_change), gd);
208 g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY],
209 "owner-change", G_CALLBACK(gd_owner_change), gd);
210 }
211