barrier/lib/platform/CXWindowsClipboard.h

/*
 * synergy-plus -- mouse and keyboard sharing utility
 * Copyright (C) 2009 The Synergy+ Project
 * Copyright (C) 2002 Chris Schoeneman
 * 
 * This package is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * found in the file COPYING that should have accompanied this file.
 * 
 * This package 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/>.
 */

#ifndef CXWINDOWSCLIPBOARD_H
#define CXWINDOWSCLIPBOARD_H

#include "IClipboard.h"
#include "ClipboardTypes.h"
#include "stdmap.h"
#include "stdlist.h"
#include "stdvector.h"
#if X_DISPLAY_MISSING
#	error X11 is required to build synergy
#else
#	include <X11/Xlib.h>
#endif

class IXWindowsClipboardConverter;

//! X11 clipboard implementation
class CXWindowsClipboard : public IClipboard {
public:
	/*!
	Use \c window as the window that owns or interacts with the
	clipboard identified by \c id.
	*/
	CXWindowsClipboard(Display*, Window window, ClipboardID id);
	virtual ~CXWindowsClipboard();

	//! Notify clipboard was lost
	/*!
	Tells clipboard it lost ownership at the given time.
	*/
	void				lost(Time);

	//! Add clipboard request
	/*!
	Adds 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);

	//! Process clipboard request
	/*!
	Continues 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);

	//! Cancel clipboard request
	/*!
	Terminate a selection request.  Returns true iff the request
	was known and handled.
	*/
	bool				destroyRequest(Window requestor);

	//! Get window
	/*!
	Returns the clipboard's window (passed the c'tor).
	*/
	Window				getWindow() const;

	//! Get selection atom
	/*!
	Returns the selection atom that identifies the clipboard to X11
	(e.g. XA_PRIMARY).
	*/
	Atom				getSelection() const;

	// IClipboard overrides
	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:
	// remove all converters from our list
	void				clearConverters();

	// get the converter for a clipboard format.  returns NULL if no
	// suitable converter.  iff onlyIfNotAdded is true then also
	// return NULL if a suitable converter was found but we already
	// have data of the converter's clipboard format.
	IXWindowsClipboardConverter*
						getConverter(Atom target,
							bool onlyIfNotAdded = false) const;

	// 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);

	// if not already checked then see if the cache is stale and, if so,
	// clear it.  this has the side effect of updating m_timeOwned.
	void				checkCache() const;

	// 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();

	//
	// 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			processEvent(Display* display, XEvent* event);

	private:
		Window			m_requestor;
		Time			m_time;
		Atom			m_property;
		bool			m_incr;
		bool			m_failed;
		bool			m_done;

		// atoms needed for the protocol
		Atom			m_atomNone;		// NONE, not None
		Atom			m_atomIncr;

		// 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];
		SInt32			m_selectionOwner;	// a Window
		SInt32			m_pad4[2];
	};

	// Motif clip item structure
	class CMotifClipItem {
	public:
		SInt32			m_id;			// kMotifClipItem
		SInt32			m_pad1[5];
		SInt32			m_size;
		SInt32			m_numFormats;
		SInt32			m_numDeletedFormats;
		SInt32			m_pad2[6];
	};

	// Motif clip format structure
	class CMotifClipFormat {
	public:
		SInt32			m_id;			// kMotifClipFormat
		SInt32			m_pad1[6];
		SInt32			m_length;
		SInt32			m_data;
		SInt32			m_type;			// an Atom
		SInt32			m_pad2[1];
		SInt32			m_deleted;
		SInt32			m_pad3[4];
	};

	// 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;

	// 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;
	void				motifFillCache();
	bool				motifGetSelection(const CMotifClipFormat*,
							Atom* actualTarget, CString* data) const;
	Time				motifGetTime() const;

	// 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;

private:
	typedef std::vector<IXWindowsClipboardConverter*> ConverterList;

	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
	mutable bool		m_checkCache;
	bool				m_cached;
	Time				m_cacheTime;
	bool				m_added[kNumFormats];
	CString				m_data[kNumFormats];

	// conversion request replies
	CReplyMap			m_replies;
	CReplyEventMask		m_eventMasks;

	// clipboard format converters
	ConverterList		m_converters;

	// atoms we'll need
	Atom				m_atomTargets;
	Atom				m_atomMultiple;
	Atom				m_atomTimestamp;
	Atom				m_atomInteger;
	Atom				m_atomAtom;
	Atom				m_atomAtomPair;
	Atom				m_atomData;
	Atom				m_atomINCR;
	Atom				m_atomMotifClipLock;
	Atom				m_atomMotifClipHeader;
	Atom				m_atomMotifClipAccess;
	Atom				m_atomGDKSelection;
};

//! Clipboard format converter interface
/*!
This interface defines the methods common to all X11 clipboard format
converters.
*/
class IXWindowsClipboardConverter : public IInterface {
public:
	//! @name accessors
	//@{

	//! Get clipboard format
	/*!
	Return the clipboard format this object converts from/to.
	*/
	virtual IClipboard::EFormat
						getFormat() const = 0;

	//! Get X11 format atom
	/*!
	Return the atom representing the X selection format that
	this object converts from/to.
	*/
	virtual Atom		getAtom() const = 0;

	//! Get X11 property datum size
	/*!
	Return the size (in bits) of data elements returned by
	toIClipboard().
	*/
	virtual int			getDataSize() const = 0;

	//! Convert from IClipboard format
	/*!
	Convert from the IClipboard format to the X selection format.
	The input data must be in the IClipboard format returned by
	getFormat().  The return data will be in the X selection
	format returned by getAtom().
	*/
	virtual CString		fromIClipboard(const CString&) const = 0;

	//! Convert to IClipboard format
	/*!
	Convert from the X selection format to the IClipboard format
	(i.e., the reverse of fromIClipboard()).
	*/
	virtual CString		toIClipboard(const CString&) const = 0;

	//@}
};

#endif