rayelliott
/
barrier
mirror of https://github.com/debauchee/barrier.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

checkpoint. changed clipboard model. the clipboard can only 

be accessed now between open()/close().  ownership of the
clipboard is asserted via the empty() method.  this parallels
the win32 model (but the win32 code hasn't been updated yet).

refactored X11 clipboard code.  moved the bulk of it into
CXWindowsClipboard and moved some comment event handling into
CXWindowsScreen.  changed how requests are processed into a
hopefully easier to understand model.  added support for getting
clipboard from and sending clipboard to motif (or at least
lesstif) clients.  sending to lesstif required a hack to work
around an apparent bug in lesstif.
This commit is contained in:
crs 2002-05-27 16:22:59 +00:00
parent 097882b71c
commit 854d2c7fbf
12 changed files with 1800 additions and 1182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
client/CXWindowsSecondaryScreen.cpp
View File

@ -1,4 +1,6 @@
#include "CXWindowsSecondaryScreen.h"
#include "CXWindowsClipboard.h"
#include "CXWindowsUtil.h"
#include "CClient.h"
#include "CThread.h"
#include "CLog.h"
@ -57,71 +59,6 @@ void CXWindowsSecondaryScreen::run()
XUnmapWindow(display, m_window);
break;
}
case SelectionClear:
// we just lost the selection. that means someone else
// grabbed the selection so this screen is now the
// selection owner. report that to the server.
if (lostClipboard(xevent.xselectionclear.selection,
xevent.xselectionclear.time)) {
m_client->onClipboardChanged(getClipboardID(
xevent.xselectionclear.selection));
}
break;
case SelectionNotify:
// notification of selection transferred. we shouldn't
// get this here because we handle them in the selection
// retrieval methods. we'll just delete the property
// with the data (satisfying the usual ICCCM protocol).
if (xevent.xselection.property != None) {
CDisplayLock display(this);
XDeleteProperty(display, m_window, xevent.xselection.property);
}
break;
case SelectionRequest:
// somebody is asking for clipboard data
if (xevent.xselectionrequest.owner == m_window) {
addClipboardRequest(m_window,
xevent.xselectionrequest.requestor,
xevent.xselectionrequest.selection,
xevent.xselectionrequest.target,
xevent.xselectionrequest.property,
xevent.xselectionrequest.time);
}
else {
// unknown window. return failure.
CDisplayLock display(this);
XEvent event;
event.xselection.type = SelectionNotify;
event.xselection.display = display;
event.xselection.requestor = xevent.xselectionrequest.requestor;
event.xselection.selection = xevent.xselectionrequest.selection;
event.xselection.target = xevent.xselectionrequest.target;
event.xselection.property = None;
event.xselection.time = xevent.xselectionrequest.time;
XSendEvent(display, xevent.xselectionrequest.requestor,
False, 0, &event);
}
break;
case PropertyNotify:
// clipboard transfers involve property changes so forward
// the event to the superclass. we only care about the
// deletion of properties.
if (xevent.xproperty.state == PropertyDelete) {
processClipboardRequest(xevent.xproperty.window,
xevent.xproperty.atom,
xevent.xproperty.time);
}
break;
case DestroyNotify:
// looks like one of the windows that requested a clipboard
// transfer has gone bye-bye.
destroyClipboardRequest(xevent.xdestroywindow.window);
break;
}
}
}
@ -315,12 +252,12 @@ void CXWindowsSecondaryScreen::mouseWheel(SInt32 delta)
void CXWindowsSecondaryScreen::setClipboard(
ClipboardID id, const IClipboard* clipboard)
{
setDisplayClipboard(id, clipboard, m_window, getCurrentTime(m_window));
setDisplayClipboard(id, clipboard);
}
void CXWindowsSecondaryScreen::grabClipboard(ClipboardID id)
{
setDisplayClipboard(id, NULL, m_window, getCurrentTime(m_window));
setDisplayClipboard(id, NULL);
}
void CXWindowsSecondaryScreen::getMousePos(
@ -350,7 +287,7 @@ SInt32 CXWindowsSecondaryScreen::getJumpZoneSize() const
void CXWindowsSecondaryScreen::getClipboard(
ClipboardID id, IClipboard* clipboard) const
{
getDisplayClipboard(id, clipboard, m_window, getCurrentTime(m_window));
getDisplayClipboard(id, clipboard);
}
void CXWindowsSecondaryScreen::onOpenDisplay()
@ -381,6 +318,13 @@ void CXWindowsSecondaryScreen::onOpenDisplay()
leaveNoLock(display);
}
CXWindowsClipboard* CXWindowsSecondaryScreen::createClipboard(
ClipboardID id)
{
CDisplayLock display(this);
return new CXWindowsClipboard(display, m_window, id);
}
void CXWindowsSecondaryScreen::onCloseDisplay()
{
assert(m_window != None);
@ -394,6 +338,13 @@ void CXWindowsSecondaryScreen::onCloseDisplay()
m_window = None;
}
void CXWindowsSecondaryScreen::onLostClipboard(
ClipboardID id)
{
// tell client that the clipboard was grabbed locally
m_client->onClipboardChanged(id);
}
long CXWindowsSecondaryScreen::getEventMask(Window w) const
{
if (w == m_window)

4
client/CXWindowsSecondaryScreen.h
View File

@ -3,6 +3,7 @@
#include "CXWindowsScreen.h"
#include "ISecondaryScreen.h"
#include <map>
#include <vector>
class CXWindowsSecondaryScreen : public CXWindowsScreen, public ISecondaryScreen {
@ -35,7 +36,10 @@ public:
protected:
// CXWindowsScreen overrides
virtual void onOpenDisplay();
virtual CXWindowsClipboard*
createClipboard(ClipboardID);
virtual void onCloseDisplay();
virtual void onLostClipboard(ClipboardID);
virtual long getEventMask(Window) const;
private:

87
server/CXWindowsPrimaryScreen.cpp
View File

@ -1,4 +1,6 @@
#include "CXWindowsPrimaryScreen.h"
#include "CXWindowsClipboard.h"
#include "CXWindowsUtil.h"
#include "CServer.h"
#include "CThread.h"
#include "CLog.h"
@ -171,71 +173,6 @@ void CXWindowsPrimaryScreen::run()
}
break;
}
case SelectionClear:
// we just lost the selection. that means someone else
// grabbed the selection so this screen is now the
// selection owner. report that to the server.
if (lostClipboard(xevent.xselectionclear.selection,
xevent.xselectionclear.time)) {
m_server->grabClipboard(getClipboardID(
xevent.xselectionclear.selection));
}
break;
case SelectionNotify:
// notification of selection transferred. we shouldn't
// get this here because we handle them in the selection
// retrieval methods. we'll just delete the property
// with the data (satisfying the usual ICCCM protocol).
if (xevent.xselection.property != None) {
CDisplayLock display(this);
XDeleteProperty(display, m_window, xevent.xselection.property);
}
break;
case SelectionRequest:
// somebody is asking for clipboard data
if (xevent.xselectionrequest.owner == m_window) {
addClipboardRequest(m_window,
xevent.xselectionrequest.requestor,
xevent.xselectionrequest.selection,
xevent.xselectionrequest.target,
xevent.xselectionrequest.property,
xevent.xselectionrequest.time);
}
else {
// unknown window. return failure.
CDisplayLock display(this);
XEvent event;
event.xselection.type = SelectionNotify;
event.xselection.display = display;
event.xselection.requestor = xevent.xselectionrequest.requestor;
event.xselection.selection = xevent.xselectionrequest.selection;
event.xselection.target = xevent.xselectionrequest.target;
event.xselection.property = None;
event.xselection.time = xevent.xselectionrequest.time;
XSendEvent(display, xevent.xselectionrequest.requestor,
False, 0, &event);
}
break;
case PropertyNotify:
// clipboard transfers involve property changes so forward
// the event to the superclass. we only care about the
// deletion of properties.
if (xevent.xproperty.state == PropertyDelete) {
processClipboardRequest(xevent.xproperty.window,
xevent.xproperty.atom,
xevent.xproperty.time);
}
break;
case DestroyNotify:
// looks like one of the windows that requested a clipboard
// transfer has gone bye-bye.
destroyClipboardRequest(xevent.xdestroywindow.window);
break;
}
}
}
@ -394,12 +331,12 @@ void CXWindowsPrimaryScreen::warpCursorNoLock(
void CXWindowsPrimaryScreen::setClipboard(
ClipboardID id, const IClipboard* clipboard)
{
setDisplayClipboard(id, clipboard, m_window, getCurrentTime(m_window));
setDisplayClipboard(id, clipboard);
}
void CXWindowsPrimaryScreen::grabClipboard(ClipboardID id)
{
setDisplayClipboard(id, NULL, m_window, getCurrentTime(m_window));
setDisplayClipboard(id, NULL);
}
void CXWindowsPrimaryScreen::getSize(
@ -416,7 +353,7 @@ SInt32 CXWindowsPrimaryScreen::getJumpZoneSize() const
void CXWindowsPrimaryScreen::getClipboard(
ClipboardID id, IClipboard* clipboard) const
{
getDisplayClipboard(id, clipboard, m_window, getCurrentTime(m_window));
getDisplayClipboard(id, clipboard);
}
KeyModifierMask CXWindowsPrimaryScreen::getToggleMask() const
@ -508,6 +445,13 @@ void CXWindowsPrimaryScreen::onOpenDisplay()
selectEvents(display, getRoot());
}
CXWindowsClipboard* CXWindowsPrimaryScreen::createClipboard(
ClipboardID id)
{
CDisplayLock display(this);
return new CXWindowsClipboard(display, m_window, id);
}
void CXWindowsPrimaryScreen::onCloseDisplay()
{
assert(m_window != None);
@ -518,6 +462,13 @@ void CXWindowsPrimaryScreen::onCloseDisplay()
m_window = None;
}
void CXWindowsPrimaryScreen::onLostClipboard(
ClipboardID id)
{
// tell server that the clipboard was grabbed locally
m_server->grabClipboard(id);
}
long CXWindowsPrimaryScreen::getEventMask(Window w) const
{
if (w == m_window)

3
server/CXWindowsPrimaryScreen.h
View File

@ -30,7 +30,10 @@ public:
protected:
// CXWindowsScreen overrides
virtual void onOpenDisplay();
virtual CXWindowsClipboard*
createClipboard(ClipboardID);
virtual void onCloseDisplay();
virtual void onLostClipboard(ClipboardID);
virtual long getEventMask(Window) const;
private:

72
synergy/CClipboard.cpp
View File

@ -5,9 +5,10 @@
// CClipboard
//
CClipboard::CClipboard()
CClipboard::CClipboard() : m_open(false), m_owner(false)
{
open(0);
empty();
close();
}
@ -16,8 +17,10 @@ CClipboard::~CClipboard()
// do nothing
}
bool CClipboard::open(Time time)
bool CClipboard::empty()
{
assert(m_open);
// clear all data
for (SInt32 index = 0; index < kNumFormats; ++index) {
m_data[index] = "";
@ -25,60 +28,90 @@ bool CClipboard::open(Time time)
}
// save time
m_timeOwned = m_time;
// we're the owner now
m_owner = true;
return true;
}
void CClipboard::add(EFormat format, const CString& data)
{
assert(m_open);
assert(m_owner);
m_data[format] = data;
m_added[format] = true;
}
bool CClipboard::open(Time time) const
{
assert(!m_open);
m_open = true;
m_time = time;
return true;
}
void CClipboard::close()
void CClipboard::close() const
{
// do nothing
}
assert(m_open);
void CClipboard::add(EFormat format, const CString& data)
{
m_data[format] = data;
m_added[format] = true;
m_open = false;
}
CClipboard::Time CClipboard::getTime() const
{
return m_time;
return m_timeOwned;
}
bool CClipboard::has(EFormat format) const
{
assert(m_open);
return m_added[format];
}
CString CClipboard::get(EFormat format) const
{
assert(m_open);
return m_data[format];
}
void CClipboard::copy(IClipboard* dst, const IClipboard* src)
bool CClipboard::copy(IClipboard* dst, const IClipboard* src)
{
assert(dst != NULL);
assert(src != NULL);
copy(dst, src, src->getTime());
return copy(dst, src, src->getTime());
}
void CClipboard::copy(IClipboard* dst,
bool CClipboard::copy(IClipboard* dst,
const IClipboard* src, Time time)
{
assert(dst != NULL);
assert(src != NULL);
if (dst->open(time)) {
for (SInt32 format = 0; format != IClipboard::kNumFormats; ++format) {
IClipboard::EFormat eFormat = (IClipboard::EFormat)format;
if (src->has(eFormat)) {
dst->add(eFormat, src->get(eFormat));
bool success = false;
if (src->open(time)) {
if (dst->open(time)) {
if (dst->empty()) {
for (SInt32 format = 0;
format != IClipboard::kNumFormats; ++format) {
IClipboard::EFormat eFormat = (IClipboard::EFormat)format;
if (src->has(eFormat)) {
dst->add(eFormat, src->get(eFormat));
}
}
success = true;
}
dst->close();
}
dst->close();
src->close();
}
return success;
}
void CClipboard::unmarshall(const CString& data, Time time)
@ -87,6 +120,7 @@ void CClipboard::unmarshall(const CString& data, Time time)
// clear existing data
open(time);
empty();
// read the number of formats
const UInt32 numFormats = readUInt32(index);

15
synergy/CClipboard.h
View File

@ -24,9 +24,10 @@ public:
CString marshall() const;
// IClipboard overrides
virtual bool open(Time);
virtual void close();
virtual bool empty();
virtual void add(EFormat, const CString& data);
virtual bool open(Time) const;
virtual void close() const;
virtual Time getTime() const;
virtual bool has(EFormat) const;
virtual CString get(EFormat) const;
@ -37,15 +38,19 @@ public:
// clipboards can be of any concrete clipboard type (and
// they don't have to be the same type). this also sets
// the timestamp to time, if provided, or the time in src.
static void copy(IClipboard* dst, const IClipboard* src);
static void copy(IClipboard* dst, const IClipboard* src, Time);
// returns true iff the copy succeeded.
static bool copy(IClipboard* dst, const IClipboard* src);
static bool copy(IClipboard* dst, const IClipboard* src, Time);
private:
UInt32 readUInt32(const char*) const;
void writeUInt32(CString*, UInt32) const;
private:
Time m_time;
mutable bool m_open;
mutable Time m_time;
bool m_owner;
Time m_timeOwned;
bool m_added[kNumFormats];
CString m_data[kNumFormats];
};

1275
synergy/CXWindowsClipboard.cpp
View File

File diff suppressed because it is too large Load Diff

250
synergy/CXWindowsClipboard.h
View File

@ -2,18 +2,262 @@
#define CXWINDOWSCLIPBOARD_H
#include "IClipboard.h"
#include "ClipboardTypes.h"
#include "CString.h"
#include <X11/Xlib.h>
#include <map>
#include <list>
class CXWindowsClipboard : public IClipboard {
public:
CXWindowsClipboard();
CXWindowsClipboard(Display*, Window, ClipboardID);
virtual ~CXWindowsClipboard();
// tell clipboard it lost ownership
void lost(Time);
// add a selection request to the request list. if the given
// owner window isn't this clipboard's window then this simply
// sends a failure event to the requestor.
void addRequest(Window owner,
Window requestor, Atom target,
::Time time, Atom property);
// continue processing a selection request. returns true if the
// request was handled, false if the request was unknown.
bool processRequest(Window requestor,
::Time time, Atom property);
// terminate a selection request. returns true iff the request
// was known and handled.
bool destroyRequest(Window requestor);
// get the clipboard's window
Window getWindow() const;
// get the clipboard selection atom
Atom getSelection() const;
// IClipboard overrides
virtual bool open();
virtual void close();
virtual bool empty();
virtual void add(EFormat, const CString& data);
virtual bool open(Time) const;
virtual void close() const;
virtual Time getTime() const;
virtual bool has(EFormat) const;
virtual CString get(EFormat) const;
private:
// convert target atom to clipboard format
EFormat getFormat(Atom target) const;
// add a non-MULTIPLE request. does not verify that the selection
// was owned at the given time. returns true if the conversion
// could be performed, false otherwise. in either case, the
// reply is inserted.
bool addSimpleRequest(
Window requestor, Atom target,
::Time time, Atom property);
// clear the cache, resetting the cached flag and the added flag for
// each format.
void clearCache() const;
void doClearCache();
// cache all formats of the selection
void fillCache() const;
void doFillCache();
// ICCCM interoperability methods
void icccmFillCache();
bool icccmGetSelection(Atom target,
Atom* actualTarget,
CString* data) const;
Time icccmGetTime() const;
// motif interoperability methods
bool motifLockClipboard() const;
void motifUnlockClipboard() const;
bool motifOwnsClipboard() const;
Time motifGetTime() const;
void motifFillCache();
// FIXME
//
// helper classes
//
// read an ICCCM conforming selection
class CICCCMGetClipboard {
public:
CICCCMGetClipboard(Window requestor, Time time, Atom property);
~CICCCMGetClipboard();
// convert the given selection to the given type. returns
// true iff the conversion was successful or the conversion
// cannot be performed (in which case *actualTarget == None).
bool readClipboard(Display* display,
Atom selection, Atom target,
Atom* actualTarget, CString* data);
private:
bool doEventPredicate(Display* display,
XEvent* event);
static Bool eventPredicate(Display* display,
XEvent* event,
XPointer arg);
private:
Window m_requestor;
Time m_time;
Atom m_property;
bool m_incr;
bool m_failed;
bool m_done;
// true iff we've received the selection notify
bool m_reading;
// the converted selection data
CString* m_data;
// the actual type of the data. if this is None then the
// selection owner cannot convert to the requested type.
Atom* m_actualTarget;
public:
// true iff the selection owner didn't follow ICCCM conventions
bool m_error;
};
// Motif structure IDs
enum { kMotifClipFormat = 1, kMotifClipItem, kMotifClipHeader };
// _MOTIF_CLIP_HEADER structure
class CMotifClipHeader {
public:
SInt32 m_id; // kMotifClipHeader
SInt32 m_pad1[3];
SInt32 m_item;
SInt32 m_pad2[4];
SInt32 m_numItems;
SInt32 m_pad3[3];
Window m_selectionOwner;
SInt32 m_pad4[2];
SInt32 m_items[1]; // m_numItems items
};
// Motif clip item structure
class CMotifClipItem {
public:
SInt32 m_id; // kMotifClipItem
SInt32 m_pad1[6];
SInt32 m_numFormats;
SInt32 m_pad2[7];
SInt32 m_formats[1]; // m_numFormats formats
};
// Motif clip format structure
class CMotifClipFormat {
public:
SInt32 m_id; // kMotifClipFormat
SInt32 m_pad1[6];
SInt32 m_length;
SInt32 m_data;
Atom m_type;
SInt32 m_pad2[6];
};
// stores data needed to respond to a selection request
class CReply {
public:
CReply(Window, Atom target, ::Time);
CReply(Window, Atom target, ::Time, Atom property,
const CString& data, Atom type, int format);
public:
// information about the request
Window m_requestor;
Atom m_target;
::Time m_time;
Atom m_property;
// true iff we've sent the notification for this reply
bool m_replied;
// true iff the reply has sent its last message
bool m_done;
// the data to send and its type and format
CString m_data;
Atom m_type;
int m_format;
// index of next byte in m_data to send
UInt32 m_ptr;
};
typedef std::list<CReply*> CReplyList;
typedef std::map<Window, CReplyList> CReplyMap;
typedef std::map<Window, long> CReplyEventMask;
// reply methods
bool insertMultipleReply(Window, ::Time, Atom);
void insertReply(CReply*);
void pushReplies();
void pushReplies(CReplyMap::iterator,
CReplyList&, CReplyList::iterator);
bool sendReply(CReply*);
void clearReplies();
void clearReplies(CReplyList&);
void sendNotify(Window requestor, Atom selection,
Atom target, Atom property, Time time);
bool wasOwnedAtTime(::Time) const;
// data conversion methods
Atom getTargetsData(CString&, int* format) const;
Atom getTimestampData(CString&, int* format) const;
Atom getStringData(CString&, int* format) const;
private:
Display* m_display;
Window m_window;
ClipboardID m_id;
Atom m_selection;
mutable bool m_open;
mutable Time m_time;
bool m_owner;
mutable Time m_timeOwned;
Time m_timeLost;
// true iff open and clipboard owned by a motif app
mutable bool m_motif;
// the added/cached clipboard data
bool m_cached;
Time m_cacheTime;
bool m_added[kNumFormats];
CString m_data[kNumFormats];
// conversion request replies
CReplyMap m_replies;
CReplyEventMask m_eventMasks;
// atoms we'll need
Atom m_atomTargets;
Atom m_atomMultiple;
Atom m_atomTimestamp;
Atom m_atomAtom;
Atom m_atomAtomPair;
Atom m_atomInteger;
Atom m_atomData;
Atom m_atomINCR;
Atom m_atomString;
Atom m_atomText;
Atom m_atomCompoundText;
Atom m_atomMotifClipLock;
Atom m_atomMotifClipHeader;
Atom m_atomMotifClipAccess;
Atom m_atomGDKSelection;
};
#endif

1006
synergy/CXWindowsScreen.cpp
View File

File diff suppressed because it is too large Load Diff

141
synergy/CXWindowsScreen.h
View File

@ -3,13 +3,11 @@
#include "BasicTypes.h"
#include "ClipboardTypes.h"
#include "CClipboard.h"
#include "CMutex.h"
#include <X11/Xlib.h>
#include <map>
#include <list>
class CString;
class IClipboard;
class CXWindowsClipboard;
class CXWindowsScreen {
public:
@ -57,141 +55,54 @@ protected:
// cause getEvent() to return false immediately and forever after
void doStop();
// determine the clipboard from the X selection. returns
// kClipboardEnd if no such clipboard.
ClipboardID getClipboardID(Atom selection);
// call when we lose the clipboard ownership (i.e. when we receive
// a SelectionClear event). returns true iff we've actually lost
// a selection we care about.
bool lostClipboard(Atom selection, Time timestamp);
// set the contents of the clipboard (i.e. primary selection)
bool setDisplayClipboard(ClipboardID,
const IClipboard* clipboard,
Window requestor, Time timestamp);
const IClipboard* clipboard);
// copy the clipboard contents to clipboard. requestor must be a
// valid window; it will be used to receive the transfer. timestamp
// should be the timestamp of the provoking event and not CurrentTime.
// if force is false then only update clipboard
void getDisplayClipboard(ClipboardID,
IClipboard* clipboard,
Window requestor, Time timestamp) const;
// add a selection request to the request list
void addClipboardRequest(
Window owner, Window requestor,
Atom selection, Atom target,
Atom property, Time time);
// continue processing a selection request
void processClipboardRequest(Window window,
Atom property, Time time);
// terminate a selection request
void destroyClipboardRequest(Window window);
// get the current server time
Time getCurrentTime(Window) const;
// copy the clipboard contents to clipboard
bool getDisplayClipboard(ClipboardID,
IClipboard* clipboard) const;
// called by openDisplay() to allow subclasses to prepare the display
virtual void onOpenDisplay() = 0;
// called by openDisplay() after onOpenDisplay() to create each clipboard
virtual CXWindowsClipboard*
createClipboard(ClipboardID) = 0;
// called by closeDisplay() to
virtual void onCloseDisplay() = 0;
// called when a clipboard is lost
virtual void onLostClipboard(ClipboardID) = 0;
// get the X event mask required by the subclass for the given window
virtual long getEventMask(Window) const = 0;
private:
class CPropertyNotifyInfo {
public:
Window m_window;
Atom m_property;
};
class CClipboardRequest {
public:
CString m_data;
UInt32 m_sent;
Window m_requestor;
Atom m_property;
Atom m_type;
int m_size;
};
typedef std::list<CClipboardRequest*> CRequestList;
typedef std::map<Window, CRequestList*> CRequestMap;
// internal event processing
bool processEvent(XEvent*);
bool getDisplayClipboard(Atom selection, Atom type,
Window requestor, Time timestamp,
Atom* outputType, CString* data) const;
bool getData(Window, Atom property,
Atom* type, SInt32* datumSize,
CString* data) const;
IClipboard::EFormat getFormat(Atom) const;
static Bool findSelectionNotify(Display*,
XEvent* xevent, XPointer arg);
static Bool findPropertyNotify(Display*,
XEvent* xevent, XPointer arg);
// determine the clipboard from the X selection. returns
// kClipboardEnd if no such clipboard.
ClipboardID getClipboardID(Atom selection) const;
bool sendClipboardData(ClipboardID, Window requestor,
Atom target, Atom property, Time time);
bool sendClipboardMultiple(ClipboardID, Window requestor,
Atom property, Time time);
bool sendClipboardTargets(ClipboardID, Window requestor,
Atom property, Time time);
bool sendClipboardTimestamp(ClipboardID, Window requestor,
Atom property, Time time);
void sendNotify(Window requestor, Atom selection,
Atom target, Atom property, Time time);
bool wasOwnedAtTime(ClipboardID, Window, Time) const;
Time getCurrentTimeNoLock(Window) const;
// continue processing a selection request
void processClipboardRequest(Window window,
Time time, Atom property);
// terminate a selection request
void destroyClipboardRequest(Window window);
private:
class CClipboardInfo {
public:
CClipboardInfo();
public:
// the contents of the clipboard and the time we got it
CClipboard m_clipboard;
// when we lost the clipboard
Time m_lostClipboard;
// the request queues
CRequestMap m_requests;
// owner of clipboard when we last asked for it
Window m_owner;
// true iff the previous request to m_owner got no reply
bool m_unresponsive;
};
Display* m_display;
int m_screen;
Window m_root;
SInt32 m_w, m_h;
bool m_stop;
// atoms we'll need
Atom m_atomTargets;
Atom m_atomMultiple;
Atom m_atomTimestamp;
Atom m_atomAtom;
Atom m_atomAtomPair;
Atom m_atomInteger;
Atom m_atomData;
Atom m_atomINCR;
Atom m_atomString;
Atom m_atomText;
Atom m_atomCompoundText;
Atom m_atomClipboard[kClipboardEnd];
Atom m_atomSynergyTime;
// clipboard info
CClipboardInfo m_clipboards[kClipboardEnd];
// clipboards
CXWindowsClipboard* m_clipboard[kClipboardEnd];
// X is not thread safe
CMutex m_mutex;

41
synergy/IClipboard.h
View File

@ -19,38 +19,41 @@ public:
// manipulators
// grab ownership of and clear the clipboard of all data.
// only add() may be called between an open() and its
// corresponding close(). if open() returns false then
// the clipboard could not be opened or grabbed; do not
// call close() in that case. iff open() returns true it
// should have saved the timestamp. the timestamp should
// be zero before the first successful open.
virtual bool open(Time) = 0;
// take ownership of the clipboard and clear all data from it.
// must be called between an open() and close(). if returns
// false then the clipboard ownership could not be taken; the
// clipboard should not be emptied in this case.
virtual bool empty() = 0;
// add data in the given format to the clipboard. data is
// passed as a string but the contents are generally not
// interpreted. may only be called after a successful empty().
virtual void add(EFormat, const CString& data) = 0;
// accessors
// open the clipboard. return true iff the clipboard could
// be opened. if open() returns true then it must be followed
// by a close() at some later time; if it returns false then
// close() must not be called.
virtual bool open(Time) const = 0;
// close the clipboard. close() must match a preceding open().
// this signals that the clipboard has been filled with all the
// necessary data. it does not mean the clipboard ownership
// should be released.
virtual void close() = 0;
// add data in the given format to the clipboard. data is
// passed as a string but the contents are generally not
// interpreted. may only be called between an open() and
// a close().
virtual void add(EFormat, const CString& data) = 0;
// accessors
virtual void close() const = 0;
// returns the timestamp passed to the last successful open().
virtual Time getTime() const = 0;
// returns true iff the clipboard contains data in the given
// format.
// format. must be called between an open() and close().
virtual bool has(EFormat) const = 0;
// returns data in the given format. rturns the empty string
// if there is no data in that format.
// if there is no data in that format. must be called between
// an open() and close().
virtual CString get(EFormat) const = 0;
};

1
synergy/Makefile
View File

@ -23,6 +23,7 @@ CXXFILES = \
CTCPSocketFactory.cpp \
CXWindowsClipboard.cpp \
CXWindowsScreen.cpp \
CXWindowsUtil.cpp \
XSynergy.cpp \
$(NULL)