Added image/bmp and text/html support to X11.

lib/base/CUnicode.cpp

@@ -23,30 +23,44 @@
 inline
 static
 UInt16
-decode16(const UInt8* n)
+decode16(const UInt8* n, bool byteSwapped)
 {
 	union x16 {
 		UInt8	n8[2];
 		UInt16	n16;
 	} c;
-	c.n8[0] = n[0];
+	if (byteSwapped) {
-	c.n8[1] = n[1];
+		c.n8[0] = n[1];
+		c.n8[1] = n[0];
+	}
+	else {
+		c.n8[0] = n[0];
+		c.n8[1] = n[1];
+	}
 	return c.n16;
 }
 
 inline
 static
 UInt32
-decode32(const UInt8* n)
+decode32(const UInt8* n, bool byteSwapped)
 {
 	union x32 {
 		UInt8	n8[4];
 		UInt32	n32;
 	} c;
-	c.n8[0] = n[0];
+	if (byteSwapped) {
-	c.n8[1] = n[1];
+		c.n8[0] = n[3];
-	c.n8[2] = n[2];
+		c.n8[1] = n[2];
-	c.n8[3] = n[3];
+		c.n8[2] = n[1];
+		c.n8[3] = n[0];
+	}
+	else {
+		c.n8[0] = n[0];
+		c.n8[1] = n[1];
+		c.n8[2] = n[2];
+		c.n8[3] = n[3];
+	}
 	return c.n32;
 }
 
@@ -366,9 +380,29 @@ CUnicode::doUCS2ToUTF8(const UInt8* data, UInt32 n, bool* errors)
 	CString dst;
 	dst.reserve(n);
 
+	// check if first character is 0xfffe or 0xfeff
+	bool byteSwapped = false;
+	if (n >= 1) {
+		switch (decode16(data, false)) {
+		case 0x0000feff:
+			data += 2;
+			--n;
+			break;
+
+		case 0x0000fffe:
+			byteSwapped = true;
+			data += 2;
+			--n;
+			break;
+
+		default:
+			break;
+		}
+	}
+
 	// convert each character
 	for (; n > 0; data += 2, --n) {
-		UInt32 c = decode16(data);
+		UInt32 c = decode16(data, byteSwapped);
 		toUTF8(dst, c, errors);
 	}
 
@@ -382,9 +416,29 @@ CUnicode::doUCS4ToUTF8(const UInt8* data, UInt32 n, bool* errors)
 	CString dst;
 	dst.reserve(n);
 
+	// check if first character is 0xfffe or 0xfeff
+	bool byteSwapped = false;
+	if (n >= 1) {
+		switch (decode32(data, false)) {
+		case 0x0000feff:
+			data += 4;
+			--n;
+			break;
+
+		case 0x0000fffe:
+			byteSwapped = true;
+			data += 4;
+			--n;
+			break;
+
+		default:
+			break;
+		}
+	}
+
 	// convert each character
 	for (; n > 0; data += 4, --n) {
-		UInt32 c = decode32(data);
+		UInt32 c = decode32(data, byteSwapped);
 		toUTF8(dst, c, errors);
 	}
 
@@ -398,9 +452,29 @@ CUnicode::doUTF16ToUTF8(const UInt8* data, UInt32 n, bool* errors)
 	CString dst;
 	dst.reserve(n);
 
+	// check if first character is 0xfffe or 0xfeff
+	bool byteSwapped = false;
+	if (n >= 1) {
+		switch (decode16(data, false)) {
+		case 0x0000feff:
+			data += 2;
+			--n;
+			break;
+
+		case 0x0000fffe:
+			byteSwapped = true;
+			data += 2;
+			--n;
+			break;
+
+		default:
+			break;
+		}
+	}
+
 	// convert each character
 	for (; n > 0; data += 2, --n) {
-		UInt32 c = decode16(data);
+		UInt32 c = decode16(data, byteSwapped);
 		if (c < 0x0000d800 || c > 0x0000dfff) {
 			toUTF8(dst, c, errors);
 		}
@@ -410,7 +484,7 @@ CUnicode::doUTF16ToUTF8(const UInt8* data, UInt32 n, bool* errors)
 			toUTF8(dst, s_replacement, NULL);
 		}
 		else if (c >= 0x0000d800 && c <= 0x0000dbff) {
-			UInt32 c2 = decode16(data);
+			UInt32 c2 = decode16(data, byteSwapped);
 			data += 2;
 			--n;
 			if (c2 < 0x0000dc00 || c2 > 0x0000dfff) {
@@ -440,9 +514,29 @@ CUnicode::doUTF32ToUTF8(const UInt8* data, UInt32 n, bool* errors)
 	CString dst;
 	dst.reserve(n);
 
+	// check if first character is 0xfffe or 0xfeff
+	bool byteSwapped = false;
+	if (n >= 1) {
+		switch (decode32(data, false)) {
+		case 0x0000feff:
+			data += 4;
+			--n;
+			break;
+
+		case 0x0000fffe:
+			byteSwapped = true;
+			data += 4;
+			--n;
+			break;
+
+		default:
+			break;
+		}
+	}
+
 	// convert each character
 	for (; n > 0; data += 4, --n) {
-		UInt32 c = decode32(data);
+		UInt32 c = decode32(data, byteSwapped);
 		if (c >= 0x00110000) {
 			setError(errors);
 			c = s_replacement;

lib/platform/CXWindowsClipboard.cpp

@@ -16,6 +16,8 @@
 #include "CXWindowsClipboardTextConverter.h"
 #include "CXWindowsClipboardUCS2Converter.h"
 #include "CXWindowsClipboardUTF8Converter.h"
+#include "CXWindowsClipboardHTMLConverter.h"
+#include "CXWindowsClipboardBMPConverter.h"
 #include "CXWindowsUtil.h"
 #include "CThread.h"
 #include "CLog.h"
@@ -68,6 +70,9 @@ CXWindowsClipboard::CXWindowsClipboard(Display* display,
 	}
 
 	// add converters, most desired first
+	m_converters.push_back(new CXWindowsClipboardHTMLConverter(m_display,
+								"text/html"));
+	m_converters.push_back(new CXWindowsClipboardBMPConverter(m_display));
 	m_converters.push_back(new CXWindowsClipboardUTF8Converter(m_display,
 								"text/plain;charset=UTF-8"));
 	m_converters.push_back(new CXWindowsClipboardUTF8Converter(m_display,

lib/platform/CXWindowsClipboardAnyBitmapConverter.cpp

@@ -0,0 +1,197 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2004 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.
+ */
+
+#include "CXWindowsClipboardAnyBitmapConverter.h"
+
+// BMP info header structure
+struct CBMPInfoHeader {
+public:
+	UInt32				biSize;
+	SInt32				biWidth;
+	SInt32				biHeight;
+	UInt16				biPlanes;
+	UInt16				biBitCount;
+	UInt32				biCompression;
+	UInt32				biSizeImage;
+	SInt32				biXPelsPerMeter;
+	SInt32				biYPelsPerMeter;
+	UInt32				biClrUsed;
+	UInt32				biClrImportant;
+};
+
+// BMP is little-endian
+static inline
+UInt16
+toLE(UInt16 data)
+{
+	union x16 {
+		UInt8	n8[2];
+		UInt16	n16;
+	} c;
+	c.n8[0] = static_cast<UInt8>(data & 0xffu);
+	c.n8[1] = static_cast<UInt8>((data >> 8) & 0xffu);
+	return c.n16;
+}
+
+static inline
+SInt32
+toLE(SInt32 data)
+{
+	union x32 {
+		UInt8	n8[4];
+		SInt32	n32;
+	} c;
+	c.n8[0] = static_cast<UInt8>(data & 0xffu);
+	c.n8[1] = static_cast<UInt8>((data >>  8) & 0xffu);
+	c.n8[2] = static_cast<UInt8>((data >> 16) & 0xffu);
+	c.n8[3] = static_cast<UInt8>((data >> 24) & 0xffu);
+	return c.n32;
+}
+
+static inline
+UInt32
+toLE(UInt32 data)
+{
+	union x32 {
+		UInt8	n8[4];
+		UInt32	n32;
+	} c;
+	c.n8[0] = static_cast<UInt8>(data & 0xffu);
+	c.n8[1] = static_cast<UInt8>((data >>  8) & 0xffu);
+	c.n8[2] = static_cast<UInt8>((data >> 16) & 0xffu);
+	c.n8[3] = static_cast<UInt8>((data >> 24) & 0xffu);
+	return c.n32;
+}
+
+static inline
+UInt16
+fromLEU16(const UInt8* data)
+{
+	return static_cast<UInt16>(data[0]) |
+			(static_cast<UInt16>(data[1]) << 8);
+}
+
+static inline
+SInt32
+fromLES32(const UInt8* data)
+{
+	return static_cast<SInt32>(static_cast<UInt32>(data[0]) |
+			(static_cast<UInt32>(data[1]) <<  8) |
+			(static_cast<UInt32>(data[2]) << 16) |
+			(static_cast<UInt32>(data[3]) << 24));
+}
+
+static inline
+UInt32
+fromLEU32(const UInt8* data)
+{
+	return static_cast<UInt32>(data[0]) |
+			(static_cast<UInt32>(data[1]) <<  8) |
+			(static_cast<UInt32>(data[2]) << 16) |
+			(static_cast<UInt32>(data[3]) << 24);
+}
+
+
+//
+// CXWindowsClipboardAnyBitmapConverter
+//
+
+CXWindowsClipboardAnyBitmapConverter::CXWindowsClipboardAnyBitmapConverter()
+{
+	// do nothing
+}
+
+CXWindowsClipboardAnyBitmapConverter::~CXWindowsClipboardAnyBitmapConverter()
+{
+	// do nothing
+}
+
+IClipboard::EFormat
+CXWindowsClipboardAnyBitmapConverter::getFormat() const
+{
+	return IClipboard::kBitmap;
+}
+
+int
+CXWindowsClipboardAnyBitmapConverter::getDataSize() const
+{
+	return 8;
+}
+
+CString
+CXWindowsClipboardAnyBitmapConverter::fromIClipboard(const CString& bmp) const
+{
+	// fill BMP info header with native-endian data
+	CBMPInfoHeader infoHeader;
+	const UInt8* rawBMPInfoHeader = reinterpret_cast<const UInt8*>(bmp.data());
+	infoHeader.biSize             = fromLEU32(rawBMPInfoHeader +  0);
+	infoHeader.biWidth            = fromLES32(rawBMPInfoHeader +  4);
+	infoHeader.biHeight           = fromLES32(rawBMPInfoHeader +  8);
+	infoHeader.biPlanes           = fromLEU16(rawBMPInfoHeader + 12);
+	infoHeader.biBitCount         = fromLEU16(rawBMPInfoHeader + 14);
+	infoHeader.biCompression      = fromLEU32(rawBMPInfoHeader + 16);
+	infoHeader.biSizeImage        = fromLEU32(rawBMPInfoHeader + 20);
+	infoHeader.biXPelsPerMeter    = fromLES32(rawBMPInfoHeader + 24);
+	infoHeader.biYPelsPerMeter    = fromLES32(rawBMPInfoHeader + 28);
+	infoHeader.biClrUsed          = fromLEU32(rawBMPInfoHeader + 32);
+	infoHeader.biClrImportant     = fromLEU32(rawBMPInfoHeader + 36);
+
+	// check that format is acceptable
+	if (infoHeader.biSize != 40 ||
+		infoHeader.biWidth == 0 || infoHeader.biHeight == 0 ||
+		infoHeader.biPlanes != 0 || infoHeader.biCompression != 0 ||
+		(infoHeader.biBitCount != 24 && infoHeader.biBitCount != 32)) {
+		return CString();
+	}
+
+	// convert to image format
+	const UInt8* rawBMPPixels = rawBMPInfoHeader + 40;
+	if (infoHeader.biBitCount == 24) {
+		return doBGRFromIClipboard(rawBMPPixels,
+							infoHeader.biWidth, infoHeader.biHeight);
+	}
+	else {
+		return doBGRAFromIClipboard(rawBMPPixels,
+							infoHeader.biWidth, infoHeader.biHeight);
+	}
+}
+
+CString
+CXWindowsClipboardAnyBitmapConverter::toIClipboard(const CString& image) const
+{
+	// convert to raw BMP data
+	UInt32 w, h, depth;
+	CString rawBMP = doToIClipboard(image, w, h, depth);
+	if (rawBMP.empty() || w == 0 || h == 0 || (depth != 24 && depth != 32)) {
+		return CString();
+	}
+
+	// fill BMP info header with little-endian data
+	CBMPInfoHeader infoHeader;
+	infoHeader.biSize          = toLE(40);
+	infoHeader.biWidth         = toLE(w);
+	infoHeader.biHeight        = toLE(h);
+	infoHeader.biPlanes        = toLE(1);
+	infoHeader.biBitCount      = toLE(depth);
+	infoHeader.biCompression   = toLE(0);		// BI_RGB
+	infoHeader.biSizeImage     = image.size();
+	infoHeader.biXPelsPerMeter = toLE(2834);	// 72 dpi
+	infoHeader.biYPelsPerMeter = toLE(2834);	// 72 dpi
+	infoHeader.biClrUsed       = toLE(0);
+	infoHeader.biClrImportant  = toLE(0);
+
+	// construct image
+	return CString(reinterpret_cast<const char*>(&infoHeader),
+							sizeof(infoHeader)) + rawBMP;
+}

lib/platform/CXWindowsClipboardAnyBitmapConverter.h

@@ -0,0 +1,59 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2004 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.
+ */
+
+#ifndef CXWINDOWSCLIPBOARDANYBITMAPCONVERTER_H
+#define CXWINDOWSCLIPBOARDANYBITMAPCONVERTER_H
+
+#include "CXWindowsClipboard.h"
+
+//! Convert to/from some text encoding
+class CXWindowsClipboardAnyBitmapConverter :
+				public IXWindowsClipboardConverter {
+public:
+	CXWindowsClipboardAnyBitmapConverter();
+	virtual ~CXWindowsClipboardAnyBitmapConverter();
+
+	// IXWindowsClipboardConverter overrides
+	virtual IClipboard::EFormat
+						getFormat() const;
+	virtual Atom		getAtom() const = 0;
+	virtual int			getDataSize() const;
+	virtual CString		fromIClipboard(const CString&) const;
+	virtual CString		toIClipboard(const CString&) const;
+
+protected:
+	//! Convert from IClipboard format
+	/*!
+	Convert raw BGR pixel data to another image format.
+	*/
+	virtual CString		doBGRFromIClipboard(const UInt8* bgrData,
+							UInt32 w, UInt32 h) const = 0;
+
+	//! Convert from IClipboard format
+	/*!
+	Convert raw BGRA pixel data to another image format.
+	*/
+	virtual CString		doBGRAFromIClipboard(const UInt8* bgrData,
+							UInt32 w, UInt32 h) const = 0;
+
+	//! Convert to IClipboard format
+	/*!
+	Convert an image into raw BGR or BGRA image data and store the
+	width, height, and image depth (24 or 32).
+	*/
+	virtual CString		doToIClipboard(const CString&,
+							UInt32& w, UInt32& h, UInt32& depth) const = 0;
+};
+
+#endif

lib/platform/CXWindowsClipboardBMPConverter.cpp

@@ -0,0 +1,126 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2004 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.
+ */
+
+#include "CXWindowsClipboardBMPConverter.h"
+
+// BMP file header structure
+struct CBMPHeader {
+public:
+	UInt16				type;
+	UInt32				size;
+	UInt16				reserved1;
+	UInt16				reserved2;
+	UInt32				offset;
+};
+
+// BMP is little-endian
+static inline
+UInt32
+fromLEU32(const UInt8* data)
+{
+	return static_cast<UInt32>(data[0]) |
+			(static_cast<UInt32>(data[1]) <<  8) |
+			(static_cast<UInt32>(data[2]) << 16) |
+			(static_cast<UInt32>(data[3]) << 24);
+}
+
+static inline
+UInt32
+toLE(UInt32 data)
+{
+	union x32 {
+		UInt8	n8[4];
+		UInt32	n32;
+	} c;
+	c.n8[0] = static_cast<UInt8>(data & 0xffu);
+	c.n8[1] = static_cast<UInt8>((data >>  8) & 0xffu);
+	c.n8[2] = static_cast<UInt8>((data >> 16) & 0xffu);
+	c.n8[3] = static_cast<UInt8>((data >> 24) & 0xffu);
+	return c.n32;
+}
+
+//
+// CXWindowsClipboardBMPConverter
+//
+
+CXWindowsClipboardBMPConverter::CXWindowsClipboardBMPConverter(
+				Display* display) :
+	m_atom(XInternAtom(display, "image/bmp", False))
+{
+	// do nothing
+}
+
+CXWindowsClipboardBMPConverter::~CXWindowsClipboardBMPConverter()
+{
+	// do nothing
+}
+
+IClipboard::EFormat
+CXWindowsClipboardBMPConverter::getFormat() const
+{
+	return IClipboard::kBitmap;
+}
+
+Atom
+CXWindowsClipboardBMPConverter::getAtom() const
+{
+	return m_atom;
+}
+
+int
+CXWindowsClipboardBMPConverter::getDataSize() const
+{
+	return 8;
+}
+
+CString
+CXWindowsClipboardBMPConverter::fromIClipboard(const CString& bmp) const
+{
+	// create BMP image
+	CBMPHeader header;
+	char* type       = reinterpret_cast<char*>(&header.type);
+	type[0]          = 'B';
+	type[1]          = 'M';
+	header.size      = toLE(14 + bmp.size());
+	header.reserved1 = 0;
+	header.reserved2 = 0;
+	header.offset    = toLE(14 + 40);
+	return CString(reinterpret_cast<const char*>(&header), 14) + bmp;
+}
+
+CString
+CXWindowsClipboardBMPConverter::toIClipboard(const CString& bmp) const
+{
+	// make sure data is big enough for a BMP file
+	if (bmp.size() <= 14 + 40) {
+		return CString();
+	}
+
+	// check BMP file header
+	const UInt8* rawBMPHeader = reinterpret_cast<const UInt8*>(bmp.data());
+	if (rawBMPHeader[0] != 'B' || rawBMPHeader[1] != 'M') {
+		return CString();
+	}
+
+	// get offset to image data
+	UInt32 offset = fromLEU32(rawBMPHeader + 10);
+
+	// construct BMP
+	if (offset == 14 + 40) {
+		return bmp.substr(14);
+	}
+	else {
+		return bmp.substr(14, 40) + bmp.substr(offset, bmp.size() - offset);
+	}
+}

lib/platform/CXWindowsClipboardBMPConverter.h

@@ -0,0 +1,39 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2004 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.
+ */
+
+#ifndef CXWINDOWSCLIPBOARDBMPCONVERTER_H
+#define CXWINDOWSCLIPBOARDBMPCONVERTER_H
+
+#include "CXWindowsClipboard.h"
+
+//! Convert to/from some text encoding
+class CXWindowsClipboardBMPConverter :
+				public IXWindowsClipboardConverter {
+public:
+	CXWindowsClipboardBMPConverter(Display* display);
+	virtual ~CXWindowsClipboardBMPConverter();
+
+	// IXWindowsClipboardConverter overrides
+	virtual IClipboard::EFormat
+						getFormat() const;
+	virtual Atom		getAtom() const;
+	virtual int			getDataSize() const;
+	virtual CString		fromIClipboard(const CString&) const;
+	virtual CString		toIClipboard(const CString&) const;
+
+private:
+	Atom				m_atom;
+};
+
+#endif

lib/platform/CXWindowsClipboardHTMLConverter.cpp

@@ -0,0 +1,62 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2004 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.
+ */
+
+#include "CXWindowsClipboardHTMLConverter.h"
+#include "CUnicode.h"
+
+//
+// CXWindowsClipboardHTMLConverter
+//
+
+CXWindowsClipboardHTMLConverter::CXWindowsClipboardHTMLConverter(
+				Display* display, const char* name) :
+	m_atom(XInternAtom(display, name, False))
+{
+	// do nothing
+}
+
+CXWindowsClipboardHTMLConverter::~CXWindowsClipboardHTMLConverter()
+{
+	// do nothing
+}
+
+IClipboard::EFormat
+CXWindowsClipboardHTMLConverter::getFormat() const
+{
+	return IClipboard::kHTML;
+}
+
+Atom
+CXWindowsClipboardHTMLConverter::getAtom() const
+{
+	return m_atom;
+}
+
+int
+CXWindowsClipboardHTMLConverter::getDataSize() const
+{
+	return 8;
+}
+
+CString
+CXWindowsClipboardHTMLConverter::fromIClipboard(const CString& data) const
+{
+	return CUnicode::UTF8ToUTF16(data);
+}
+
+CString
+CXWindowsClipboardHTMLConverter::toIClipboard(const CString& data) const
+{
+	return CUnicode::UTF16ToUTF8(data);
+}

lib/platform/CXWindowsClipboardHTMLConverter.h

@@ -0,0 +1,41 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2004 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.
+ */
+
+#ifndef CXWINDOWSCLIPBOARDHTMLCONVERTER_H
+#define CXWINDOWSCLIPBOARDHTMLCONVERTER_H
+
+#include "CXWindowsClipboard.h"
+
+//! Convert to/from HTML encoding
+class CXWindowsClipboardHTMLConverter : public IXWindowsClipboardConverter {
+public:
+	/*!
+	\c name is converted to an atom and that is reported by getAtom().
+	*/
+	CXWindowsClipboardHTMLConverter(Display* display, const char* name);
+	virtual ~CXWindowsClipboardHTMLConverter();
+
+	// IXWindowsClipboardConverter overrides
+	virtual IClipboard::EFormat
+						getFormat() const;
+	virtual Atom		getAtom() const;
+	virtual int			getDataSize() const;
+	virtual CString		fromIClipboard(const CString&) const;
+	virtual CString		toIClipboard(const CString&) const;
+
+private:
+	Atom				m_atom;
+};
+
+#endif

lib/platform/Makefile.am

@@ -15,6 +15,9 @@ NULL =
 
 XWINDOWS_SOURCE_FILES =						\
 	CXWindowsClipboard.cpp					\
+	CXWindowsClipboardAnyBitmapConverter.cpp\
+	CXWindowsClipboardBMPConverter.cpp		\
+	CXWindowsClipboardHTMLConverter.cpp		\
 	CXWindowsClipboardTextConverter.cpp		\
 	CXWindowsClipboardUCS2Converter.cpp		\
 	CXWindowsClipboardUTF8Converter.cpp		\
@@ -24,6 +27,9 @@ XWINDOWS_SOURCE_FILES =						\
 	CXWindowsScreenSaver.cpp				\
 	CXWindowsUtil.cpp						\
 	CXWindowsClipboard.h					\
+	CXWindowsClipboardAnyBitmapConverter.h	\
+	CXWindowsClipboardBMPConverter.h		\
+	CXWindowsClipboardHTMLConverter.h		\
 	CXWindowsClipboardTextConverter.h		\
 	CXWindowsClipboardUCS2Converter.h		\
 	CXWindowsClipboardUTF8Converter.h		\
@@ -36,6 +42,8 @@ XWINDOWS_SOURCE_FILES =						\
 MSWINDOWS_SOURCE_FILES =					\
 	CMSWindowsClipboard.cpp					\
 	CMSWindowsClipboardAnyTextConverter.cpp	\
+	CMSWindowsClipboardBitmapConverter.cpp	\
+	CMSWindowsClipboardHTMLConverter.cpp	\
 	CMSWindowsClipboardTextConverter.cpp	\
 	CMSWindowsClipboardUTF16Converter.cpp	\
 	CMSWindowsDesks.cpp						\
@@ -46,6 +54,8 @@ MSWINDOWS_SOURCE_FILES =					\
 	CMSWindowsUtil.cpp						\
 	CMSWindowsClipboard.h					\
 	CMSWindowsClipboardAnyTextConverter.h	\
+	CMSWindowsClipboardBitmapConverter.h	\
+	CMSWindowsClipboardHTMLConverter.h		\
 	CMSWindowsClipboardTextConverter.h		\
 	CMSWindowsClipboardUTF16Converter.h		\
 	CMSWindowsDesks.h						\

lib/synergy/IClipboard.h

@@ -40,6 +40,17 @@ public:
 	via add() and retrieved via get() must be in one of these formats.
 	Platform dependent clipboard subclasses can and should present any
 	suitable formats derivable from these formats.
+
+	\c kText is a text format encoded in UTF-8.  Newlines are LF (not
+	CR or LF/CR).
+
+	\k kBitmap is an image format.  The data is a BMP file without the
+	14 byte header (i.e. starting at the INFOHEADER) and with the image
+	data immediately following the 40 byte INFOHEADER.
+
+	\k kHTML is a text format encoded in UTF-8 and containing a valid
+	HTML fragment (but not necessarily a complete HTML document).
+	Newlines are LF.
 	*/
 	enum EFormat {
 		kText,			//!< Text format, UTF-8, newline is LF