]> git.proxmox.com Git - mirror_qemu.git/blob - ui/gtk-clipboard.c
8d8a636fd1fadda3bf8f2d43d78781041e9f5326
[mirror_qemu.git] / ui / gtk-clipboard.c
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/main-loop.h"
23
24 #include "ui/gtk.h"
25
26 static QemuClipboardSelection gd_find_selection(GtkDisplayState *gd,
27 GtkClipboard *clipboard)
28 {
29 QemuClipboardSelection s;
30
31 for (s = 0; s < QEMU_CLIPBOARD_SELECTION__COUNT; s++) {
32 if (gd->gtkcb[s] == clipboard) {
33 return s;
34 }
35 }
36 return QEMU_CLIPBOARD_SELECTION_CLIPBOARD;
37 }
38
39 static void gd_clipboard_get_data(GtkClipboard *clipboard,
40 GtkSelectionData *selection_data,
41 guint selection_info,
42 gpointer data)
43 {
44 GtkDisplayState *gd = data;
45 QemuClipboardSelection s = gd_find_selection(gd, clipboard);
46 QemuClipboardType type = QEMU_CLIPBOARD_TYPE_TEXT;
47 g_autoptr(QemuClipboardInfo) info = NULL;
48
49 info = qemu_clipboard_info_ref(qemu_clipboard_info(s));
50
51 qemu_clipboard_request(info, type);
52 while (info == qemu_clipboard_info(s) &&
53 info->types[type].available &&
54 info->types[type].data == NULL) {
55 main_loop_wait(false);
56 }
57
58 if (info == qemu_clipboard_info(s) && gd->cbowner[s]) {
59 gtk_selection_data_set_text(selection_data,
60 info->types[type].data,
61 info->types[type].size);
62 } else {
63 /* clipboard owner changed while waiting for the data */
64 }
65 }
66
67 static void gd_clipboard_clear(GtkClipboard *clipboard,
68 gpointer data)
69 {
70 GtkDisplayState *gd = data;
71 QemuClipboardSelection s = gd_find_selection(gd, clipboard);
72
73 gd->cbowner[s] = false;
74 }
75
76 static void gd_clipboard_update_info(GtkDisplayState *gd,
77 QemuClipboardInfo *info)
78 {
79 QemuClipboardSelection s = info->selection;
80 bool self_update = info->owner == &gd->cbpeer;
81
82 if (info != qemu_clipboard_info(s)) {
83 gd->cbpending[s] = 0;
84 if (!self_update) {
85 g_autoptr(GtkTargetList) list = NULL;
86 GtkTargetEntry *targets;
87 gint n_targets;
88
89 list = gtk_target_list_new(NULL, 0);
90 if (info->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
91 gtk_target_list_add_text_targets(list, 0);
92 }
93 targets = gtk_target_table_new_from_list(list, &n_targets);
94
95 gtk_clipboard_clear(gd->gtkcb[s]);
96 if (targets) {
97 gd->cbowner[s] = true;
98 gtk_clipboard_set_with_data(gd->gtkcb[s],
99 targets, n_targets,
100 gd_clipboard_get_data,
101 gd_clipboard_clear,
102 gd);
103
104 gtk_target_table_free(targets, n_targets);
105 }
106 }
107 return;
108 }
109
110 if (self_update) {
111 return;
112 }
113
114 /*
115 * Clipboard got updated, with data probably. No action here, we
116 * are waiting for updates in gd_clipboard_get_data().
117 */
118 }
119
120 static void gd_clipboard_notify(Notifier *notifier, void *data)
121 {
122 GtkDisplayState *gd =
123 container_of(notifier, GtkDisplayState, cbpeer.notifier);
124 QemuClipboardNotify *notify = data;
125
126 switch (notify->type) {
127 case QEMU_CLIPBOARD_UPDATE_INFO:
128 gd_clipboard_update_info(gd, notify->info);
129 return;
130 case QEMU_CLIPBOARD_RESET_SERIAL:
131 /* ignore */
132 return;
133 }
134 }
135
136 static void gd_clipboard_request(QemuClipboardInfo *info,
137 QemuClipboardType type)
138 {
139 GtkDisplayState *gd = container_of(info->owner, GtkDisplayState, cbpeer);
140 char *text;
141
142 switch (type) {
143 case QEMU_CLIPBOARD_TYPE_TEXT:
144 text = gtk_clipboard_wait_for_text(gd->gtkcb[info->selection]);
145 if (text) {
146 qemu_clipboard_set_data(&gd->cbpeer, info, type,
147 strlen(text), text, true);
148 g_free(text);
149 }
150 break;
151 default:
152 break;
153 }
154 }
155
156 static void gd_owner_change(GtkClipboard *clipboard,
157 GdkEvent *event,
158 gpointer data)
159 {
160 GtkDisplayState *gd = data;
161 QemuClipboardSelection s = gd_find_selection(gd, clipboard);
162 QemuClipboardInfo *info;
163
164 if (gd->cbowner[s]) {
165 /* ignore notifications about our own grabs */
166 return;
167 }
168
169
170 switch (event->owner_change.reason) {
171 case GDK_OWNER_CHANGE_NEW_OWNER:
172 info = qemu_clipboard_info_new(&gd->cbpeer, s);
173 if (gtk_clipboard_wait_is_text_available(clipboard)) {
174 info->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true;
175 }
176
177 qemu_clipboard_update(info);
178 qemu_clipboard_info_unref(info);
179 break;
180 default:
181 qemu_clipboard_peer_release(&gd->cbpeer, s);
182 gd->cbowner[s] = false;
183 break;
184 }
185 }
186
187 void gd_clipboard_init(GtkDisplayState *gd)
188 {
189 gd->cbpeer.name = "gtk";
190 gd->cbpeer.notifier.notify = gd_clipboard_notify;
191 gd->cbpeer.request = gd_clipboard_request;
192 qemu_clipboard_peer_register(&gd->cbpeer);
193
194 gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD] =
195 gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
196 gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY] =
197 gtk_clipboard_get(GDK_SELECTION_PRIMARY);
198 gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY] =
199 gtk_clipboard_get(GDK_SELECTION_SECONDARY);
200
201 g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD],
202 "owner-change", G_CALLBACK(gd_owner_change), gd);
203 g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY],
204 "owner-change", G_CALLBACK(gd_owner_change), gd);
205 g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY],
206 "owner-change", G_CALLBACK(gd_owner_change), gd);
207 }