]> git.proxmox.com Git - mirror_qemu.git/blob - ui/gtk-clipboard.c
d58fd761abdf81bc0a9da3bac00fb21b9a967d8a
[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-common.h"
23 #include "qemu/main-loop.h"
24
25 #include "ui/gtk.h"
26
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
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
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
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 gtk_clipboard_set_with_data(gd->gtkcb[s],
100 targets, n_targets,
101 gd_clipboard_get_data,
102 gd_clipboard_clear,
103 gd);
104
105 gtk_target_table_free(targets, n_targets);
106 }
107 }
108 return;
109 }
110
111 if (self_update) {
112 return;
113 }
114
115 /*
116 * Clipboard got updated, with data probably. No action here, we
117 * are waiting for updates in gd_clipboard_get_data().
118 */
119 }
120
121 static void gd_clipboard_notify(Notifier *notifier, void *data)
122 {
123 GtkDisplayState *gd =
124 container_of(notifier, GtkDisplayState, cbpeer.notifier);
125 QemuClipboardNotify *notify = data;
126
127 switch (notify->type) {
128 case QEMU_CLIPBOARD_UPDATE_INFO:
129 gd_clipboard_update_info(gd, notify->info);
130 return;
131 case QEMU_CLIPBOARD_RESET_SERIAL:
132 /* ignore */
133 return;
134 }
135 }
136
137 static void gd_clipboard_request(QemuClipboardInfo *info,
138 QemuClipboardType type)
139 {
140 GtkDisplayState *gd = container_of(info->owner, GtkDisplayState, cbpeer);
141 char *text;
142
143 switch (type) {
144 case QEMU_CLIPBOARD_TYPE_TEXT:
145 text = gtk_clipboard_wait_for_text(gd->gtkcb[info->selection]);
146 if (text) {
147 qemu_clipboard_set_data(&gd->cbpeer, info, type,
148 strlen(text), text, true);
149 g_free(text);
150 }
151 break;
152 default:
153 break;
154 }
155 }
156
157 static void gd_owner_change(GtkClipboard *clipboard,
158 GdkEvent *event,
159 gpointer data)
160 {
161 GtkDisplayState *gd = data;
162 QemuClipboardSelection s = gd_find_selection(gd, clipboard);
163 QemuClipboardInfo *info;
164
165 if (gd->cbowner[s]) {
166 /* ignore notifications about our own grabs */
167 return;
168 }
169
170
171 switch (event->owner_change.reason) {
172 case GDK_OWNER_CHANGE_NEW_OWNER:
173 info = qemu_clipboard_info_new(&gd->cbpeer, s);
174 if (gtk_clipboard_wait_is_text_available(clipboard)) {
175 info->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true;
176 }
177
178 qemu_clipboard_update(info);
179 qemu_clipboard_info_unref(info);
180 break;
181 default:
182 qemu_clipboard_peer_release(&gd->cbpeer, s);
183 gd->cbowner[s] = false;
184 break;
185 }
186 }
187
188 void gd_clipboard_init(GtkDisplayState *gd)
189 {
190 gd->cbpeer.name = "gtk";
191 gd->cbpeer.notifier.notify = gd_clipboard_notify;
192 gd->cbpeer.request = gd_clipboard_request;
193 qemu_clipboard_peer_register(&gd->cbpeer);
194
195 gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD] =
196 gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
197 gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY] =
198 gtk_clipboard_get(GDK_SELECTION_PRIMARY);
199 gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY] =
200 gtk_clipboard_get(GDK_SELECTION_SECONDARY);
201
202 g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD],
203 "owner-change", G_CALLBACK(gd_owner_change), gd);
204 g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY],
205 "owner-change", G_CALLBACK(gd_owner_change), gd);
206 g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY],
207 "owner-change", G_CALLBACK(gd_owner_change), gd);
208 }