Mirrored_Repos/LookingGlass
1
0
Fork 0
mirror of https://github.com/gnif/LookingGlass.git synced 2024-11-25 23:07:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[client] initial host to client clipboard sync working

Browse Source
This commit is contained in:
Geoffrey McRae 2019-02-24 11:43:32 +11:00
parent 0a2fbe1f7f
commit d8b01c0257
6 changed files with 445 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
client/CMakeLists.txt
View File

@ -16,6 +16,7 @@ pkg_check_modules(PKGCONFIG REQUIRED
spice-protocol spice-protocol
fontconfig fontconfig
x11 x11
xfixes
wayland-egl wayland-egl
libconfig libconfig
nettle nettle

182
client/clipboard/x11.c
View File

@ -20,15 +20,27 @@ Place, Suite 330, Boston, MA 02111-1307 USA
#include "lg-clipboard.h" #include "lg-clipboard.h"
#include "debug.h" #include "debug.h"
#include <X11/extensions/Xfixes.h>
struct state struct state
{ {
Display * display; Display * display;
Window window; Window window;
Atom aSelection; Atom aSelection;
Atom aCurSelection;
Atom aTargets; Atom aTargets;
Atom aTypes[LG_CLIPBOARD_DATA_MAX]; Atom aSelData;
Atom aIncr;
Atom aTypes[LG_CLIPBOARD_DATA_NONE];
LG_ClipboardReleaseFn releaseFn;
LG_ClipboardRequestFn requestFn; LG_ClipboardRequestFn requestFn;
LG_ClipboardNotifyFn notifyFn;
LG_ClipboardDataFn dataFn;
LG_ClipboardData type; LG_ClipboardData type;
// XFixes vars
int eventBase;
int errorBase;
}; };
static struct state * this = NULL; static struct state * this = NULL;
@ -47,7 +59,11 @@ static const char * x11_cb_getName()
return "X11"; return "X11";
} }
static bool x11_cb_init(SDL_SysWMinfo * wminfo) static bool x11_cb_init(
SDL_SysWMinfo * wminfo,
LG_ClipboardReleaseFn releaseFn,
LG_ClipboardNotifyFn notifyFn,
LG_ClipboardDataFn dataFn)
{ {
// final sanity check // final sanity check
if (wminfo->subsystem != SDL_SYSWM_X11) if (wminfo->subsystem != SDL_SYSWM_X11)
@ -59,12 +75,18 @@ static bool x11_cb_init(SDL_SysWMinfo * wminfo)
this = (struct state *)malloc(sizeof(struct state)); this = (struct state *)malloc(sizeof(struct state));
memset(this, 0, sizeof(struct state)); memset(this, 0, sizeof(struct state));
this->display = wminfo->info.x11.display; this->display = wminfo->info.x11.display;
this->window = wminfo->info.x11.window; this->window = wminfo->info.x11.window;
this->aSelection = XInternAtom(this->display, "CLIPBOARD", False); this->aSelection = XInternAtom(this->display, "CLIPBOARD", False);
this->aTargets = XInternAtom(this->display, "TARGETS" , False); this->aTargets = XInternAtom(this->display, "TARGETS" , False);
this->aSelData = XInternAtom(this->display, "SEL_DATA" , False);
this->aIncr = XInternAtom(this->display, "INCR" , False);
this->aCurSelection = BadValue;
this->releaseFn = releaseFn;
this->notifyFn = notifyFn;
this->dataFn = dataFn;
for(int i = 0; i < LG_CLIPBOARD_DATA_MAX; ++i) for(int i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
{ {
this->aTypes[i] = XInternAtom(this->display, atomTypes[i], False); this->aTypes[i] = XInternAtom(this->display, atomTypes[i], False);
if (this->aTypes[i] == BadAlloc || this->aTypes[i] == BadValue) if (this->aTypes[i] == BadAlloc || this->aTypes[i] == BadValue)
@ -79,6 +101,18 @@ static bool x11_cb_init(SDL_SysWMinfo * wminfo)
// we need the raw X events // we need the raw X events
SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE); SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE);
// use xfixes to get clipboard change notifications
if (!XFixesQueryExtension(this->display, &this->eventBase, &this->errorBase))
{
DEBUG_ERROR("failed to initialize xfixes");
free(this);
this = NULL;
return false;
}
XFixesSelectSelectionInput(this->display,DefaultRootWindow(this->display), XA_PRIMARY , XFixesSetSelectionOwnerNotifyMask);
XFixesSelectSelectionInput(this->display,DefaultRootWindow(this->display), this->aSelection, XFixesSetSelectionOwnerNotifyMask);
return true; return true;
} }
@ -154,7 +188,7 @@ static void x11_cb_wmevent(SDL_SysWMmsg * msg)
} }
// look to see if we can satisfy the data type // look to see if we can satisfy the data type
for(int i = 0; i < LG_CLIPBOARD_DATA_MAX; ++i) for(int i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
if (this->aTypes[i] == e.xselectionrequest.target && this->type == i) if (this->aTypes[i] == e.xselectionrequest.target && this->type == i)
{ {
// request the data // request the data
@ -172,15 +206,113 @@ static void x11_cb_wmevent(SDL_SysWMmsg * msg)
XFlush(this->display); XFlush(this->display);
} }
if (e.type == SelectionNotify) if (e.type == SelectionClear && (
e.xselectionclear.selection == XA_PRIMARY ||
e.xselectionclear.selection == this->aSelection)
)
{ {
DEBUG_WARN("FIXME: SelectionNotify"); this->aCurSelection = BadValue;
this->releaseFn();
return; return;
} }
if (e.type == SelectionClear) // if someone selected data
if (e.type == this->eventBase + XFixesSelectionNotify && (
((XFixesSelectionNotifyEvent *)&e)->selection == XA_PRIMARY ||
((XFixesSelectionNotifyEvent *)&e)->selection == this->aSelection)
)
{ {
DEBUG_WARN("FIXME: SelectionClear"); // ask for the data type
XFixesSelectionNotifyEvent * sne = (XFixesSelectionNotifyEvent *)&e;
// remember which selection we are working with
this->aCurSelection = sne->selection;
XConvertSelection(
this->display,
sne->selection,
this->aTargets,
this->aTargets,
this->window,
CurrentTime);
return;
}
if (e.type == SelectionNotify)
{
if (e.xselection.property == None)
return;
Atom type;
int format;
unsigned long itemCount, after;
unsigned char *data;
XGetWindowProperty(
this->display,
this->window,
e.xselection.property,
0, ~0L, // start and length
True , // delete the property
AnyPropertyType,
&type,
&format,
&itemCount,
&after,
&data);
// the target list
if (e.xselection.property == this->aTargets)
{
// the format is 32-bit and we must have data
// this is technically incorrect however as it's
// an array of padded 64-bit values
if (!data || format != 32)
{
this->notifyFn(LG_CLIPBOARD_DATA_NONE);
if (data)
XFree(data);
return;
}
// see if we support any of the targets listed
const uint64_t * targets = (const uint64_t *)data;
for(unsigned long i = 0; i < itemCount; ++i)
{
for(int n = 0; n < LG_CLIPBOARD_DATA_NONE; ++n)
if (this->aTypes[n] == targets[i])
{
// we have a match, so send the notification
this->notifyFn(n);
XFree(data);
return;
}
}
// no matches
this->notifyFn(LG_CLIPBOARD_DATA_NONE);
XFree(data);
return;
}
if (format == this->aIncr)
{
DEBUG_WARN("fixme: large paste buffers are not yet supported");
}
else
{
for(int i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
if (this->aTypes[i] == type)
{
this->dataFn(i, data, itemCount);
XFree(data);
return;
}
DEBUG_WARN("clipboard data (%s) not in a supported format", XGetAtomName(this->display, type));
}
XFree(data);
return; return;
} }
} }
@ -194,11 +326,35 @@ static void x11_cb_notice(LG_ClipboardRequestFn requestFn, LG_ClipboardData type
XFlush(this->display); XFlush(this->display);
} }
static void x11_cb_release()
{
this->requestFn = NULL;
XSetSelectionOwner(this->display, XA_PRIMARY , None, CurrentTime);
XSetSelectionOwner(this->display, this->aSelection, None, CurrentTime);
XFlush(this->display);
}
static void x11_cb_request(LG_ClipboardData type)
{
if (this->aCurSelection == BadValue)
return;
XConvertSelection(
this->display,
this->aCurSelection,
this->aTypes[type],
this->aSelData,
this->window,
CurrentTime);
}
const LG_Clipboard LGC_X11 = const LG_Clipboard LGC_X11 =
{ {
.getName = x11_cb_getName, .getName = x11_cb_getName,
.init = x11_cb_init, .init = x11_cb_init,
.free = x11_cb_free, .free = x11_cb_free,
.wmevent = x11_cb_wmevent, .wmevent = x11_cb_wmevent,
.notice = x11_cb_notice .notice = x11_cb_notice,
.release = x11_cb_release,
.request = x11_cb_request
}; };

13
client/lg-clipboard.h
View File

@ -31,18 +31,23 @@ typedef enum LG_ClipboardData
LG_CLIPBOARD_DATA_TIFF, LG_CLIPBOARD_DATA_TIFF,
LG_CLIPBOARD_DATA_JPEG, LG_CLIPBOARD_DATA_JPEG,
LG_CLIPBOARD_DATA_MAX // enum max, not a data type LG_CLIPBOARD_DATA_NONE // enum max, not a data type
} }
LG_ClipboardData; LG_ClipboardData;
typedef void (* LG_ClipboardReplyFn )(void * opaque, LG_ClipboardData type, uint8_t * data, uint32_t size); typedef void (* LG_ClipboardReplyFn )(void * opaque, const LG_ClipboardData type, uint8_t * data, uint32_t size);
typedef void (* LG_ClipboardRequestFn)(LG_ClipboardReplyFn replyFn, void * opaque); typedef void (* LG_ClipboardRequestFn)(LG_ClipboardReplyFn replyFn, void * opaque);
typedef void (* LG_ClipboardReleaseFn)();
typedef void (* LG_ClipboardNotifyFn)(LG_ClipboardData type);
typedef void (* LG_ClipboardDataFn )(const LG_ClipboardData type, uint8_t * data, size_t size);
typedef const char * (* LG_ClipboardGetName)(); typedef const char * (* LG_ClipboardGetName)();
typedef bool (* LG_ClipboardInit)(SDL_SysWMinfo * wminfo); typedef bool (* LG_ClipboardInit)(SDL_SysWMinfo * wminfo, LG_ClipboardReleaseFn releaseFn, LG_ClipboardNotifyFn notifyFn, LG_ClipboardDataFn dataFn);
typedef void (* LG_ClipboardFree)(); typedef void (* LG_ClipboardFree)();
typedef void (* LG_ClipboardWMEvent)(SDL_SysWMmsg * msg); typedef void (* LG_ClipboardWMEvent)(SDL_SysWMmsg * msg);
typedef void (* LG_ClipboardNotice)(LG_ClipboardRequestFn requestFn, LG_ClipboardData type); typedef void (* LG_ClipboardNotice)(LG_ClipboardRequestFn requestFn, LG_ClipboardData type);
typedef void (* LG_ClipboardRelease)();
typedef void (* LG_ClipboardRequest)(LG_ClipboardData type);
typedef struct LG_Clipboard typedef struct LG_Clipboard
{ {
@ -51,5 +56,7 @@ typedef struct LG_Clipboard
LG_ClipboardFree free; LG_ClipboardFree free;
LG_ClipboardWMEvent wmevent; LG_ClipboardWMEvent wmevent;
LG_ClipboardNotice notice; LG_ClipboardNotice notice;
LG_ClipboardRelease release;
LG_ClipboardRequest request;
} }
LG_Clipboard; LG_Clipboard;

88
client/main.c
View File

@ -492,7 +492,60 @@ static inline const uint32_t mapScancode(SDL_Scancode scancode)
return ps2; return ps2;
} }
void clipboardRequestFn(const LG_ClipboardReplyFn replyFn, void * opaque) static LG_ClipboardData spice_type_to_clipboard_type(const SpiceDataType type)
{
switch(type)
{
case SPICE_DATA_TEXT: return LG_CLIPBOARD_DATA_TEXT; break;
case SPICE_DATA_PNG : return LG_CLIPBOARD_DATA_PNG ; break;
case SPICE_DATA_BMP : return LG_CLIPBOARD_DATA_BMP ; break;
case SPICE_DATA_TIFF: return LG_CLIPBOARD_DATA_TIFF; break;
case SPICE_DATA_JPEG: return LG_CLIPBOARD_DATA_JPEG; break;
default:
DEBUG_ERROR("invalid spice data type");
return LG_CLIPBOARD_DATA_NONE;
}
}
static SpiceDataType clipboard_type_to_spice_type(const LG_ClipboardData type)
{
switch(type)
{
case LG_CLIPBOARD_DATA_TEXT: return SPICE_DATA_TEXT; break;
case LG_CLIPBOARD_DATA_PNG : return SPICE_DATA_PNG ; break;
case LG_CLIPBOARD_DATA_BMP : return SPICE_DATA_BMP ; break;
case LG_CLIPBOARD_DATA_TIFF: return SPICE_DATA_TIFF; break;
case LG_CLIPBOARD_DATA_JPEG: return SPICE_DATA_JPEG; break;
default:
DEBUG_ERROR("invalid clipboard data type");
return SPICE_DATA_NONE;
}
}
void clipboardRelease()
{
spice_clipboard_release();
// another application just took the clipboard ownership
}
void clipboardNotify(const LG_ClipboardData type)
{
if (type == LG_CLIPBOARD_DATA_NONE)
{
spice_clipboard_release();
return;
}
spice_clipboard_grab(clipboard_type_to_spice_type(type));
}
void clipboardData(const LG_ClipboardData type, uint8_t * data, size_t size)
{
spice_clipboard_data(clipboard_type_to_spice_type(type), data, (uint32_t)size);
}
void clipboardRequest(const LG_ClipboardReplyFn replyFn, void * opaque)
{ {
state.cbReplyData = opaque; state.cbReplyData = opaque;
state.cbReplyFn = replyFn; state.cbReplyFn = replyFn;
@ -506,18 +559,7 @@ void spiceClipboardNotice(const SpiceDataType type)
return; return;
state.cbType = type; state.cbType = type;
state.lgc->notice(clipboardRequest, spice_type_to_clipboard_type(type));
LG_ClipboardData t;
switch(type)
{
case LG_CLIPBOARD_DATA_TEXT: t = SPICE_DATA_TEXT; break;
case LG_CLIPBOARD_DATA_PNG : t = SPICE_DATA_PNG ; break;
case LG_CLIPBOARD_DATA_BMP : t = SPICE_DATA_BMP ; break;
case LG_CLIPBOARD_DATA_TIFF: t = SPICE_DATA_TIFF; break;
case LG_CLIPBOARD_DATA_JPEG: t = SPICE_DATA_JPEG; break;
}
state.lgc->notice(clipboardRequestFn, t);
} }
void spiceClipboardData(const SpiceDataType type, uint8_t * buffer, uint32_t size) void spiceClipboardData(const SpiceDataType type, uint8_t * buffer, uint32_t size)
@ -538,6 +580,18 @@ void spiceClipboardData(const SpiceDataType type, uint8_t * buffer, uint32_t siz
state.cbReplyFn(state.cbReplyData, type, buffer, size); state.cbReplyFn(state.cbReplyData, type, buffer, size);
} }
void spiceClipboardRelease()
{
if (state.lgc && state.lgc->release)
state.lgc->release();
}
void spiceClipboardRequest(const SpiceDataType type)
{
if (state.lgc && state.lgc->request)
state.lgc->request(spice_type_to_clipboard_type(type));
}
int eventFilter(void * userdata, SDL_Event * event) int eventFilter(void * userdata, SDL_Event * event)
{ {
static bool serverMode = false; static bool serverMode = false;
@ -982,7 +1036,7 @@ int run()
if (state.lgc) if (state.lgc)
{ {
DEBUG_INFO("Using Clipboard: %s", state.lgc->getName()); DEBUG_INFO("Using Clipboard: %s", state.lgc->getName());
if (!state.lgc->init(&wminfo)) if (!state.lgc->init(&wminfo, clipboardRelease, clipboardNotify, clipboardData))
{ {
DEBUG_WARN("Failed to initialize the clipboard interface, continuing anyway"); DEBUG_WARN("Failed to initialize the clipboard interface, continuing anyway");
state.lgc = NULL; state.lgc = NULL;
@ -1022,7 +1076,11 @@ int run()
if (params.useSpice) if (params.useSpice)
{ {
spice_set_on_clipboard_cb(spiceClipboardNotice, spiceClipboardData); spice_set_clipboard_cb(
spiceClipboardNotice,
spiceClipboardData,
spiceClipboardRelease,
spiceClipboardRequest);
if (!spice_connect(params.spiceHost, params.spicePort, "")) if (!spice_connect(params.spiceHost, params.spicePort, ""))
{ {
DEBUG_ERROR("Failed to connect to spice server"); DEBUG_ERROR("Failed to connect to spice server");

220
client/spice/spice.c
View File

@ -116,13 +116,17 @@ struct Spice
bool cbSupported; bool cbSupported;
bool cbSelection; bool cbSelection;
bool cbGrabbed; // clipboard variables
SpiceDataType cbType; bool cbAgentGrabbed;
uint8_t * cbBuffer; bool cbClientGrabbed;
uint32_t cbRemain; SpiceDataType cbType;
uint32_t cbSize; uint8_t * cbBuffer;
SpiceClipboardNotice cbNoticeFn; uint32_t cbRemain;
SpiceClipboardData cbDataFn; uint32_t cbSize;
SpiceClipboardNotice cbNoticeFn;
SpiceClipboardData cbDataFn;
SpiceClipboardRelease cbReleaseFn;
SpiceClipboardRequest cbRequestFn;
}; };
// globals // globals
@ -150,6 +154,10 @@ bool spice_agent_connect ();
bool spice_agent_send_caps(bool request); bool spice_agent_send_caps(bool request);
void spice_agent_on_clipboard(); void spice_agent_on_clipboard();
// utility functions
static uint32_t spice_type_to_agent_type(SpiceDataType type);
static SpiceDataType agent_type_to_spice_type(uint32_t type);
// thread safe read/write methods // thread safe read/write methods
bool spice_write_msg (struct SpiceChannel * channel, uint32_t type, const void * buffer, const ssize_t size); bool spice_write_msg (struct SpiceChannel * channel, uint32_t type, const void * buffer, const ssize_t size);
bool spice_agent_write_msg (uint32_t type, const void * buffer, const ssize_t size); bool spice_agent_write_msg (uint32_t type, const void * buffer, const ssize_t size);
@ -207,6 +215,9 @@ void spice_disconnect()
spice.cbBuffer = NULL; spice.cbBuffer = NULL;
spice.cbRemain = 0; spice.cbRemain = 0;
spice.cbSize = 0; spice.cbSize = 0;
spice.cbAgentGrabbed = false;
spice.cbClientGrabbed = false;
} }
// ============================================================================ // ============================================================================
@ -1008,7 +1019,9 @@ bool spice_agent_process(uint32_t dataSize)
if (msg.type == VD_AGENT_CLIPBOARD_RELEASE) if (msg.type == VD_AGENT_CLIPBOARD_RELEASE)
{ {
DEBUG_PROTO("VD_AGENT_CLIPBOARD_RELEASE"); DEBUG_PROTO("VD_AGENT_CLIPBOARD_RELEASE");
spice.cbGrabbed = false; spice.cbAgentGrabbed = false;
if (spice.cbReleaseFn)
spice.cbReleaseFn();
return true; return true;
} }
@ -1058,6 +1071,8 @@ bool spice_agent_process(uint32_t dataSize)
else else
{ {
DEBUG_PROTO("VD_AGENT_CLIPBOARD_REQUEST"); DEBUG_PROTO("VD_AGENT_CLIPBOARD_REQUEST");
if (spice.cbRequestFn)
spice.cbRequestFn(agent_type_to_spice_type(type));
return true; return true;
} }
} }
@ -1077,19 +1092,8 @@ bool spice_agent_process(uint32_t dataSize)
// there is zero documentation on the types field, it might be a bitfield // there is zero documentation on the types field, it might be a bitfield
// but for now we are going to assume it's not. // but for now we are going to assume it's not.
switch(types[0]) spice.cbType = agent_type_to_spice_type(types[0]);
{ spice.cbAgentGrabbed = true;
case VD_AGENT_CLIPBOARD_UTF8_TEXT : spice.cbType = SPICE_DATA_TEXT; break;
case VD_AGENT_CLIPBOARD_IMAGE_PNG : spice.cbType = SPICE_DATA_PNG ; break;
case VD_AGENT_CLIPBOARD_IMAGE_BMP : spice.cbType = SPICE_DATA_BMP ; break;
case VD_AGENT_CLIPBOARD_IMAGE_TIFF: spice.cbType = SPICE_DATA_TIFF; break;
case VD_AGENT_CLIPBOARD_IMAGE_JPG : spice.cbType = SPICE_DATA_JPEG; break;
default:
DEBUG_WARN("Unknown clipboard data type: %u", types[0]);
return true;
}
spice.cbGrabbed = true;
if (spice.cbSelection) if (spice.cbSelection)
{ {
// Windows doesnt support this, so until it's needed there is no point messing with it // Windows doesnt support this, so until it's needed there is no point messing with it
@ -1166,11 +1170,14 @@ bool spice_agent_write_msg(uint32_t type, const void * buffer, const ssize_t siz
return false; return false;
} }
if (spice_write_nl(&spice.scMain, buffer, size) != size) if (buffer && size)
{ {
LG_UNLOCK(spice.scMain.lock); if (spice_write_nl(&spice.scMain, buffer, size) != size)
DEBUG_ERROR("failed to write agent data payload"); {
return false; LG_UNLOCK(spice.scMain.lock);
DEBUG_ERROR("failed to write agent data payload");
return false;
}
} }
LG_UNLOCK(spice.scMain.lock); LG_UNLOCK(spice.scMain.lock);
@ -1455,11 +1462,43 @@ bool spice_mouse_release(uint32_t button)
// ============================================================================ // ============================================================================
static uint32_t spice_type_to_agent_type(SpiceDataType type)
{
switch(type)
{
case SPICE_DATA_TEXT: return VD_AGENT_CLIPBOARD_UTF8_TEXT ; break;
case SPICE_DATA_PNG : return VD_AGENT_CLIPBOARD_IMAGE_PNG ; break;
case SPICE_DATA_BMP : return VD_AGENT_CLIPBOARD_IMAGE_BMP ; break;
case SPICE_DATA_TIFF: return VD_AGENT_CLIPBOARD_IMAGE_TIFF; break;
case SPICE_DATA_JPEG: return VD_AGENT_CLIPBOARD_IMAGE_JPG ; break;
default:
DEBUG_ERROR("unsupported spice data type specified");
return VD_AGENT_CLIPBOARD_NONE;
}
}
static SpiceDataType agent_type_to_spice_type(uint32_t type)
{
switch(type)
{
case VD_AGENT_CLIPBOARD_UTF8_TEXT : return SPICE_DATA_TEXT; break;
case VD_AGENT_CLIPBOARD_IMAGE_PNG : return SPICE_DATA_PNG ; break;
case VD_AGENT_CLIPBOARD_IMAGE_BMP : return SPICE_DATA_BMP ; break;
case VD_AGENT_CLIPBOARD_IMAGE_TIFF: return SPICE_DATA_TIFF; break;
case VD_AGENT_CLIPBOARD_IMAGE_JPG : return SPICE_DATA_JPEG; break;
default:
DEBUG_ERROR("unsupported agent data type specified");
return SPICE_DATA_NONE;
}
}
// ============================================================================
bool spice_clipboard_request(SpiceDataType type) bool spice_clipboard_request(SpiceDataType type)
{ {
VDAgentClipboardRequest req; VDAgentClipboardRequest req;
if (!spice.cbGrabbed) if (!spice.cbAgentGrabbed)
{ {
DEBUG_ERROR("the agent has not grabbed any data yet"); DEBUG_ERROR("the agent has not grabbed any data yet");
return false; return false;
@ -1471,18 +1510,7 @@ bool spice_clipboard_request(SpiceDataType type)
return false; return false;
} }
switch(type) req.type = spice_type_to_agent_type(type);
{
case SPICE_DATA_TEXT: req.type = VD_AGENT_CLIPBOARD_UTF8_TEXT ; break;
case SPICE_DATA_PNG : req.type = VD_AGENT_CLIPBOARD_IMAGE_PNG ; break;
case SPICE_DATA_BMP : req.type = VD_AGENT_CLIPBOARD_IMAGE_BMP ; break;
case SPICE_DATA_TIFF: req.type = VD_AGENT_CLIPBOARD_IMAGE_TIFF; break;
case SPICE_DATA_JPEG: req.type = VD_AGENT_CLIPBOARD_IMAGE_JPG ; break;
default:
DEBUG_ERROR("invalid clipboard data type requested");
return false;
}
if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_REQUEST, &req, sizeof(req))) if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_REQUEST, &req, sizeof(req)))
{ {
DEBUG_ERROR("failed to request clipboard data"); DEBUG_ERROR("failed to request clipboard data");
@ -1494,18 +1522,124 @@ bool spice_clipboard_request(SpiceDataType type)
// ============================================================================ // ============================================================================
bool spice_set_on_clipboard_cb(SpiceClipboardNotice cbNoticeFn, SpiceClipboardData cbDataFn) bool spice_set_clipboard_cb(SpiceClipboardNotice cbNoticeFn, SpiceClipboardData cbDataFn, SpiceClipboardRelease cbReleaseFn, SpiceClipboardRequest cbRequestFn)
{ {
if ((cbNoticeFn && !cbDataFn) || (cbDataFn && !cbNoticeFn)) if ((cbNoticeFn && !cbDataFn) || (cbDataFn && !cbNoticeFn))
{ {
DEBUG_ERROR("Clipboard callback notice and data callbacks must be specified"); DEBUG_ERROR("clipboard callback notice and data callbacks must be specified");
return false; return false;
} }
spice.cbNoticeFn = cbNoticeFn; spice.cbNoticeFn = cbNoticeFn;
spice.cbDataFn = cbDataFn; spice.cbDataFn = cbDataFn;
spice.cbReleaseFn = cbReleaseFn;
spice.cbRequestFn = cbRequestFn;
return true; return true;
} }
// ============================================================================ // ============================================================================
bool spice_clipboard_grab(SpiceDataType type)
{
// release first if we have grabbed previously
if (spice.cbClientGrabbed && !spice_clipboard_release())
return false;
if (type == SPICE_DATA_NONE)
{
DEBUG_ERROR("grab type is invalid");
return false;
}
if (spice.cbSelection)
{
uint8_t req[8] = { VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD };
((uint32_t*)req)[1] = spice_type_to_agent_type(type);
if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_GRAB, req, sizeof(req)))
{
DEBUG_ERROR("failed to grab the clipboard");
return false;
}
spice.cbClientGrabbed = true;
return true;
}
uint32_t req = spice_type_to_agent_type(type);
if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_GRAB, &req, sizeof(req)))
{
DEBUG_ERROR("failed to grab the clipboard");
return false;
}
spice.cbClientGrabbed = true;
return true;
}
// ============================================================================
bool spice_clipboard_release()
{
// check if if there is anything to release first
if (!spice.cbClientGrabbed)
return true;
if (spice.cbSelection)
{
uint8_t req[4] = { VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD };
if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_RELEASE, req, sizeof(req)))
{
DEBUG_ERROR("failed to release the clipboard");
return false;
}
spice.cbClientGrabbed = false;
return true;
}
if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_RELEASE, NULL, 0))
{
DEBUG_ERROR("failed to release the clipboard");
return false;
}
spice.cbClientGrabbed = false;
return true;
}
// ============================================================================
bool spice_clipboard_data(SpiceDataType type, uint8_t * data, size_t size)
{
uint8_t * buffer;
uint8_t bufSize;
if (spice.cbSelection)
{
bufSize = 8 + size;
buffer = (uint8_t *)malloc(bufSize);
buffer[0] = VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD;
buffer[1] = buffer[2] = buffer[3] = 0;
((uint32_t*)buffer)[1] = spice_type_to_agent_type(type);
memcpy(buffer + 8, data, size);
}
else
{
bufSize = 4 + size;
buffer = (uint8_t *)malloc(bufSize);
((uint32_t*)buffer)[0] = spice_type_to_agent_type(type);
memcpy(buffer + 4, data, size);
}
if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD, buffer, bufSize))
{
DEBUG_ERROR("failed to write the clipboard data");
free(buffer);
return false;
}
free(buffer);
return true;
}

19
client/spice/spice.h
View File

@ -27,12 +27,16 @@ typedef enum SpiceDataType
SPICE_DATA_PNG, SPICE_DATA_PNG,
SPICE_DATA_BMP, SPICE_DATA_BMP,
SPICE_DATA_TIFF, SPICE_DATA_TIFF,
SPICE_DATA_JPEG SPICE_DATA_JPEG,
SPICE_DATA_NONE
} }
SpiceDataType; SpiceDataType;
typedef void (*SpiceClipboardNotice)(const SpiceDataType type); typedef void (*SpiceClipboardNotice )(const SpiceDataType type);
typedef void (*SpiceClipboardData )(const SpiceDataType type, uint8_t * buffer, uint32_t size); typedef void (*SpiceClipboardData )(const SpiceDataType type, uint8_t * buffer, uint32_t size);
typedef void (*SpiceClipboardRelease)();
typedef void (*SpiceClipboardRequest)(const SpiceDataType type);
bool spice_connect(const char * host, const unsigned short port, const char * password); bool spice_connect(const char * host, const unsigned short port, const char * password);
void spice_disconnect(); void spice_disconnect();
@ -48,6 +52,13 @@ bool spice_mouse_press (uint32_t button);
bool spice_mouse_release (uint32_t button); bool spice_mouse_release (uint32_t button);
bool spice_clipboard_request(SpiceDataType type); bool spice_clipboard_request(SpiceDataType type);
bool spice_clipboard_grab (SpiceDataType type);
bool spice_clipboard_release();
bool spice_clipboard_data (SpiceDataType type, uint8_t * data, size_t size);
/* events */ /* events */
bool spice_set_on_clipboard_cb(SpiceClipboardNotice cbNoticeFn, SpiceClipboardData cbDataFn); bool spice_set_clipboard_cb(
SpiceClipboardNotice cbNoticeFn,
SpiceClipboardData cbDataFn,
SpiceClipboardRelease cbReleaseFn,
SpiceClipboardRequest cbRequestFn);