mirror of
https://gitlab.com/qemu-project/qemu
synced 2024-09-06 18:05:37 +00:00
![Marc-André Lureau](/assets/img/avatar_default.png)
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com> Message-Id: <20220323155743.1585078-33-marcandre.lureau@redhat.com> Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
208 lines
6.5 KiB
C
208 lines
6.5 KiB
C
/*
|
|
* GTK UI -- clipboard support
|
|
*
|
|
* Copyright (C) 2021 Gerd Hoffmann <kraxel@redhat.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "qemu/main-loop.h"
|
|
|
|
#include "ui/gtk.h"
|
|
|
|
static QemuClipboardSelection gd_find_selection(GtkDisplayState *gd,
|
|
GtkClipboard *clipboard)
|
|
{
|
|
QemuClipboardSelection s;
|
|
|
|
for (s = 0; s < QEMU_CLIPBOARD_SELECTION__COUNT; s++) {
|
|
if (gd->gtkcb[s] == clipboard) {
|
|
return s;
|
|
}
|
|
}
|
|
return QEMU_CLIPBOARD_SELECTION_CLIPBOARD;
|
|
}
|
|
|
|
static void gd_clipboard_get_data(GtkClipboard *clipboard,
|
|
GtkSelectionData *selection_data,
|
|
guint selection_info,
|
|
gpointer data)
|
|
{
|
|
GtkDisplayState *gd = data;
|
|
QemuClipboardSelection s = gd_find_selection(gd, clipboard);
|
|
QemuClipboardType type = QEMU_CLIPBOARD_TYPE_TEXT;
|
|
g_autoptr(QemuClipboardInfo) info = NULL;
|
|
|
|
info = qemu_clipboard_info_ref(qemu_clipboard_info(s));
|
|
|
|
qemu_clipboard_request(info, type);
|
|
while (info == qemu_clipboard_info(s) &&
|
|
info->types[type].available &&
|
|
info->types[type].data == NULL) {
|
|
main_loop_wait(false);
|
|
}
|
|
|
|
if (info == qemu_clipboard_info(s) && gd->cbowner[s]) {
|
|
gtk_selection_data_set_text(selection_data,
|
|
info->types[type].data,
|
|
info->types[type].size);
|
|
} else {
|
|
/* clipboard owner changed while waiting for the data */
|
|
}
|
|
}
|
|
|
|
static void gd_clipboard_clear(GtkClipboard *clipboard,
|
|
gpointer data)
|
|
{
|
|
GtkDisplayState *gd = data;
|
|
QemuClipboardSelection s = gd_find_selection(gd, clipboard);
|
|
|
|
gd->cbowner[s] = false;
|
|
}
|
|
|
|
static void gd_clipboard_update_info(GtkDisplayState *gd,
|
|
QemuClipboardInfo *info)
|
|
{
|
|
QemuClipboardSelection s = info->selection;
|
|
bool self_update = info->owner == &gd->cbpeer;
|
|
|
|
if (info != qemu_clipboard_info(s)) {
|
|
gd->cbpending[s] = 0;
|
|
if (!self_update) {
|
|
g_autoptr(GtkTargetList) list = NULL;
|
|
GtkTargetEntry *targets;
|
|
gint n_targets;
|
|
|
|
list = gtk_target_list_new(NULL, 0);
|
|
if (info->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
|
|
gtk_target_list_add_text_targets(list, 0);
|
|
}
|
|
targets = gtk_target_table_new_from_list(list, &n_targets);
|
|
|
|
gtk_clipboard_clear(gd->gtkcb[s]);
|
|
if (targets) {
|
|
gd->cbowner[s] = true;
|
|
gtk_clipboard_set_with_data(gd->gtkcb[s],
|
|
targets, n_targets,
|
|
gd_clipboard_get_data,
|
|
gd_clipboard_clear,
|
|
gd);
|
|
|
|
gtk_target_table_free(targets, n_targets);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (self_update) {
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clipboard got updated, with data probably. No action here, we
|
|
* are waiting for updates in gd_clipboard_get_data().
|
|
*/
|
|
}
|
|
|
|
static void gd_clipboard_notify(Notifier *notifier, void *data)
|
|
{
|
|
GtkDisplayState *gd =
|
|
container_of(notifier, GtkDisplayState, cbpeer.notifier);
|
|
QemuClipboardNotify *notify = data;
|
|
|
|
switch (notify->type) {
|
|
case QEMU_CLIPBOARD_UPDATE_INFO:
|
|
gd_clipboard_update_info(gd, notify->info);
|
|
return;
|
|
case QEMU_CLIPBOARD_RESET_SERIAL:
|
|
/* ignore */
|
|
return;
|
|
}
|
|
}
|
|
|
|
static void gd_clipboard_request(QemuClipboardInfo *info,
|
|
QemuClipboardType type)
|
|
{
|
|
GtkDisplayState *gd = container_of(info->owner, GtkDisplayState, cbpeer);
|
|
char *text;
|
|
|
|
switch (type) {
|
|
case QEMU_CLIPBOARD_TYPE_TEXT:
|
|
text = gtk_clipboard_wait_for_text(gd->gtkcb[info->selection]);
|
|
if (text) {
|
|
qemu_clipboard_set_data(&gd->cbpeer, info, type,
|
|
strlen(text), text, true);
|
|
g_free(text);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void gd_owner_change(GtkClipboard *clipboard,
|
|
GdkEvent *event,
|
|
gpointer data)
|
|
{
|
|
GtkDisplayState *gd = data;
|
|
QemuClipboardSelection s = gd_find_selection(gd, clipboard);
|
|
QemuClipboardInfo *info;
|
|
|
|
if (gd->cbowner[s]) {
|
|
/* ignore notifications about our own grabs */
|
|
return;
|
|
}
|
|
|
|
|
|
switch (event->owner_change.reason) {
|
|
case GDK_OWNER_CHANGE_NEW_OWNER:
|
|
info = qemu_clipboard_info_new(&gd->cbpeer, s);
|
|
if (gtk_clipboard_wait_is_text_available(clipboard)) {
|
|
info->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true;
|
|
}
|
|
|
|
qemu_clipboard_update(info);
|
|
qemu_clipboard_info_unref(info);
|
|
break;
|
|
default:
|
|
qemu_clipboard_peer_release(&gd->cbpeer, s);
|
|
gd->cbowner[s] = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void gd_clipboard_init(GtkDisplayState *gd)
|
|
{
|
|
gd->cbpeer.name = "gtk";
|
|
gd->cbpeer.notifier.notify = gd_clipboard_notify;
|
|
gd->cbpeer.request = gd_clipboard_request;
|
|
qemu_clipboard_peer_register(&gd->cbpeer);
|
|
|
|
gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD] =
|
|
gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
|
|
gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY] =
|
|
gtk_clipboard_get(GDK_SELECTION_PRIMARY);
|
|
gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY] =
|
|
gtk_clipboard_get(GDK_SELECTION_SECONDARY);
|
|
|
|
g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD],
|
|
"owner-change", G_CALLBACK(gd_owner_change), gd);
|
|
g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY],
|
|
"owner-change", G_CALLBACK(gd_owner_change), gd);
|
|
g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY],
|
|
"owner-change", G_CALLBACK(gd_owner_change), gd);
|
|
}
|