text = &(text[i]);
					i = 0;
					break;

				default:
					Display_DoGlyph(font, flags, mixmode, x, y, bgcolour, fgcolour, text, i);
					i++;
					break;
			}
		}
	}

	void Display_SaveDesktop(uint32 offset, int x, int y, int cx, int cy)
	{
		GdiFlush();

		uint8 * data =
			(uint8 *)m_displayBufferRaw +
			x * m_displayBufferByteDepth +
			(m_displayBufferHeight - y - cy) * m_displayBufferStride;

		cache_put_desktop
		(
			/*This*/NULL,
			offset * m_displayBufferByteDepth,
			cx,
			cy,
			m_displayBufferStride,
			m_displayBufferByteDepth,
			data
		);
	}

	void Display_RestoreDesktop(uint32 offset, int x, int y, int cx, int cy)
	{
		int fromstride = cx * m_displayBufferByteDepth;

		const uint8 * src = cache_get_desktop(/*This*/NULL, offset, cx, cy, m_displayBufferByteDepth);
		
		uint8 * dst =
			(uint8 *)m_displayBufferRaw +
			x * m_displayBufferByteDepth +
			(m_displayBufferHeight - y - cy) * m_displayBufferStride;

		GdiFlush();

		for(int i = 0; i < cy; ++ i)
		{
			memcpy(dst, src, fromstride);
			src += fromstride;
			dst += m_displayBufferStride;
		}

		Display_RepaintArea(x, y, cx, cy);
	}


	void Display_BeginUpdate()
	{
		EnterCriticalSection(&m_displayBufferMutex);
		m_displayBufferSave = SaveDC(m_displayBuffer);
	}

	void Display_EndUpdate()
	{
		RestoreDC(m_displayBuffer, m_displayBufferSave);
		LeaveCriticalSection(&m_displayBufferMutex);
	}

	/*
		This is the input window. It receives the keyboard and mouse input from
		the user, and it's the only window that can receive the keyboard focus.
		It completely fills its parent, the console window, and it runs in its
		own thread for performance reasons and because of technical reasons
		involving keyboard hooks in full-screen mode
	*/
	HWND m_inputWindow;
	HCURSOR m_inputCursor;

	LRESULT InputWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		switch(uMsg)
		{
		case WM_DESTROY:
			PostQuitMessage(0);
			return 0;

			/* Keyboard stuff */
			// TODO: we need a good way to post output cross-thread
		case WM_SYSKEYDOWN:
		case WM_KEYDOWN:		
			//rdp_send_input(This, GetMessageTime(), RDP_INPUT_SCANCODE, RDP_KEYPRESS | (lparam & 0x1000000 ? KBD_FLAG_EXT : 0), LOBYTE(HIWORD(lparam)), 0);
			break;

		case WM_SYSKEYUP:
		case WM_KEYUP:
			//rdp_send_input(This, GetMessageTime(), RDP_INPUT_SCANCODE, RDP_KEYRELEASE | (lparam & 0x1000000 ? KBD_FLAG_EXT : 0), LOBYTE(HIWORD(lparam)), 0);
			break;

			/* Mouse stuff */
			// Cursor shape
		case WM_SETCURSOR:
			if(LOWORD(lParam) == HTCLIENT)
			{
				SetCursor(m_inputCursor);
				return TRUE;
			}

			break;

			// Movement
		case WM_MOUSEMOVE:
			//rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE, LOWORD(lparam), HIWORD(lparam));
			break;

			// Buttons
			// TODO: X buttons
		case WM_LBUTTONDOWN:
			//rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
			break;

		case WM_RBUTTONDOWN:
			//rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON2 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
			break;

		case WM_MBUTTONDOWN:
			//rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON3 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
			break;

		case WM_LBUTTONUP:
			//rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1, LOWORD(lparam), HIWORD(lparam));
			break;

		case WM_RBUTTONUP:
			//rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON2, LOWORD(lparam), HIWORD(lparam));
			break;

		case WM_MBUTTONUP:
			//rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON3, LOWORD(lparam), HIWORD(lparam));
			break;

			// Wheel
		case WM_MOUSEWHEEL:
			//mstsc_mousewheel(This, (SHORT)HIWORD(wparam), lparam);
			break;
		}

		return DefWindowProc(m_inputWindow, uMsg, wParam, lParam);
	}

public:
};

#pragma warning(push)
#pragma warning(disable: 4584)

/* The ActiveX control */
class RdpClient SEALED_:
	/* COM basics */
	public IUnknown,
	public IDispatch,

	/* ActiveX stuff */
	public IConnectionPointContainer,
	public IDataObject,
	public IObjectSafety,
	public IOleControl,
	public IOleInPlaceActiveObject,
	public IOleInPlaceObject,
	public IOleObject,
	public IOleWindow,
	public IPersist,
	public IPersistPropertyBag,
	public IPersistStorage,
	public IPersistStreamInit,
	public IProvideClassInfo,
	public IProvideClassInfo2,
	public IQuickActivate,
	public IViewObject,
	public IViewObject2,

	// NOTE: the original has a vestigial, non-functional implementation of this, which we omit
	// ISpecifyPropertyPages

	// Hidden interfaces, not available through QueryInterface
	public IConnectionPoint,

	/* RDP client interface */
	public MSTSCLib::IMsRdpClient4,
	public MSTSCLib::IMsRdpClientNonScriptable2

	// NOTE: implemented by inner classes due to requiring distinct IDispatch implementations
	// IMsRdpClientAdvancedSettings4
	// IMsRdpClientSecuredSettings
{
private:
	/* An endless amount of COM glue */
	// Reference counting
	LONG m_refCount;

#ifdef _DEBUG
	DWORD m_apartmentThreadId;

	bool InsideApartment() const
	{
		return GetCurrentThreadId() == m_apartmentThreadId;
	}
#endif

	// Aggregation support
	IUnknown * m_punkOuter;

	class RdpClientInner: public IUnknown
	{
	private:
		RdpClient * Outer()
		{
			return InnerToOuter(this);
		}

	public:
		virtual STDMETHODIMP IUnknown::QueryInterface(REFIID riid, void ** ppvObject)
		{
			return Outer()->queryInterface(riid, ppvObject);
		}

		virtual STDMETHODIMP_(ULONG) IUnknown::AddRef()
		{
			return Outer()->addRef();
		}

		virtual STDMETHODIMP_(ULONG) IUnknown::Release()
		{
			return Outer()->release();
		}

	}
	m_inner;

	// Persistence support
	CLSID m_classId;

	// Late binding support
	unsigned m_typeLibIndex;
	ITypeLib * m_typeLib;
	ITypeInfo * m_dispTypeInfo;

	// Event sinks
	size_t m_EventSinksCount;

	union
	{
		MSTSCLib::IMsTscAxEvents * m_EventSinksStatic[1];
		MSTSCLib::IMsTscAxEvents ** m_EventSinks;
	};

	// OLE control glue
	HWND m_controlWindow;
	IOleClientSite * m_clientSite;
	IOleInPlaceSite * m_inPlaceSite;
	IOleAdviseHolder * m_adviseHolder;
	LONG m_freezeEvents;
	bool m_uiActive;

	// UrlMon security
	DWORD m_SafetyOptions;

	bool IsSafeForScripting() const
	{
		return m_SafetyOptions & INTERFACESAFE_FOR_UNTRUSTED_CALLER;
	}

	/* Glue to interface to rdesktop-core */
	RdpClientUI * m_clientUI;
	RDPCLIENT m_protocolState;
	HANDLE m_protocolThread;
	HANDLE m_protocolThreadWaitingReconnection;
	bool m_reconnectAborted;
	bool m_actuallyConnected;
	bool m_loggedIn;

	/* Properties */
	// Storage fields
	// NOTE: keep sorted by alignment (pointers and handles, integers, enumerations, booleans)
	BSTR m_Domain;
	BSTR m_UserName;
	BSTR m_DisconnectedText;
	BSTR m_ConnectingText;
	BSTR m_FullScreenTitle;
	BSTR m_StartProgram;
	BSTR m_WorkDir;
	BSTR m_ConnectedStatusText;
	BSTR m_ClearTextPassword; // FIXME! dangerous, shouldn't store in cleartext!
	BSTR m_RdpdrLocalPrintingDocName;
	BSTR m_RdpdrClipCleanTempDirString;
	BSTR m_RdpdrClipPasteInfoString;
	BSTR m_KeyboardLayoutString;
	LPSTR m_Server;
	LPSTR m_LoadBalanceInfo;
	// TODO: plugin DLLs
	HWND m_UIParentWindowHandle;
	long m_DesktopWidth;
	long m_DesktopHeight;
	long m_StartConnected;
	long m_ColorDepth;
	long m_KeyboardHookMode;
	long m_AudioRedirectionMode;
	long m_TransportType;
	long m_SasSequence;
	long m_RDPPort;
	long m_HotKeyFullScreen;
	long m_HotKeyAltEsc;
	long m_HotKeyAltShiftTab;
	long m_HotKeyAltSpace;
	long m_HotKeyAltTab;
	long m_HotKeyCtrlAltDel;
	long m_HotKeyCtrlEsc;
	long m_orderDrawThresold;
	long m_BitmapCacheSize;
	long m_BitmapVirtualCacheSize;
	long m_NumBitmapCaches;
	long m_brushSupportLevel;
	long m_minInputSendInterval;
	long m_InputEventsAtOnce;
	long m_maxEventCount;
	long m_keepAliveInternal;
	long m_shutdownTimeout;
	long m_overallConnectionTimeout;
	long m_singleConnectionTimeout;
	long m_MinutesToIdleTimeout;
	long m_BitmapVirtualCache16BppSize;
	long m_BitmapVirtualCache24BppSize;
	long m_PerformanceFlags;
	long m_MaxReconnectAttempts;
	unsigned int m_AuthenticationLevel;

	MSTSCLib::ExtendedDisconnectReasonCode m_ExtendedDisconnectReason;

	bool m_Connected;
	bool m_Compress;
	bool m_BitmapPersistence;
	bool m_allowBackgroundInput;
	bool m_ContainerHandledFullScreen;
	bool m_DisableRdpdr;
	bool m_SecuredSettingsEnabled;
	bool m_FullScreen;
	bool m_AcceleratorPassthrough;
	bool m_ShadowBitmap;
	bool m_EncryptionEnabled;
	bool m_DedicatedTerminal;
	bool m_DisableCtrlAltDel;
	bool m_EnableWindowsKey;
	bool m_DoubleClickDetect;
	bool m_MaximizeShell;
	bool m_ScaleBitmapCachesByBpp;
	bool m_CachePersistenceActive;
	bool m_ConnectToServerConsole;
	bool m_SmartSizing; // FIXME: this can be set while the control is connected
	bool m_DisplayConnectionBar;
	bool m_PinConnectionBar;
	bool m_GrabFocusOnConnect;
	bool m_RedirectDrives;
	bool m_RedirectPrinters;
	bool m_RedirectPorts;
	bool m_RedirectSmartCards;
	bool m_NotifyTSPublicKey;
	bool m_CanAutoReconnect;
	bool m_EnableAutoReconnect;
	bool m_ConnectionBarShowMinimizeButton;
	bool m_ConnectionBarShowRestoreButton;

	// Generic getters/setters
	HRESULT GetProperty(BSTR& prop, BSTR * retVal) const
	{
		assert(InsideApartment());

		if(retVal == NULL)
			return E_POINTER;

		*retVal = SysAllocStringLen(prop, SysStringLen(prop));

		if(*retVal == NULL)
			return E_OUTOFMEMORY;

		return S_OK;
	}

	HRESULT GetProperty(LPSTR& prop, BSTR * retVal) const
	{
		assert(InsideApartment());

		if(retVal == NULL)
			return E_POINTER;

		*retVal = LpszToBstr(prop);

		if(*retVal == NULL)
			return E_OUTOFMEMORY;

		return S_OK;
	}

	HRESULT SetProperty(BSTR& prop, BSTR newValue)
	{
		assert(InsideApartment());

		if(m_Connected)
			return E_FAIL;

		SysFreeString(prop);

		UINT len = SysStringLen(newValue);

		if(len)
		{
			// no embedded NULs, please
			if(len != lstrlenW(newValue))
				return E_INVALIDARG;

			prop = SysAllocStringLen(newValue, len);

			if(prop == NULL)
				return E_OUTOFMEMORY;
		}
		else
			prop = NULL;

		return S_OK;
	}

	HRESULT ReplaceProperty(BSTR& prop, BSTR newValue)
	{
		assert(InsideApartment());
		assert((prop == NULL && newValue == NULL) || prop != newValue);

		SysFreeString(prop);
		prop = newValue;
		return S_OK;
	}

	HRESULT SetProperty(LPSTR& prop, BSTR newValue)
	{
		assert(InsideApartment());

		if(m_Connected)
			return E_FAIL;

		delete[] prop;

		if(SysStringLen(newValue))
		{
			prop = BstrToLpsz(newValue);

			if(prop == NULL)
				return E_OUTOFMEMORY;
		}
		else
			prop = NULL;

		return S_OK;
	}

	HRESULT ReplaceProperty(LPSTR& prop, LPSTR newValue)
	{
		assert(InsideApartment());
		assert((prop == NULL && newValue == NULL) || prop != newValue);

		if(prop)
			delete[] prop;

		prop = newValue;
		return S_OK;
	}

	template<class Type> HRESULT SetProperty(bool& prop, const Type& newValue)
	{
		assert(InsideApartment());

		if(m_Connected)
			return E_FAIL;

		prop = !!newValue;
		return S_OK;
	}

	template<class Type> HRESULT SetProperty(Type& prop, const Type& newValue)
	{
		assert(InsideApartment());

		if(m_Connected)
			return E_FAIL;

		prop = newValue;
		return S_OK;
	}

	template<class Type> HRESULT GetProperty(const bool& prop, Type * retVal) const
	{
		assert(InsideApartment());

		if(retVal == NULL)
			return E_POINTER;

		*retVal = prop ? VARIANT_TRUE : VARIANT_FALSE;
		return S_OK;
	}

	template<class Type> HRESULT GetProperty(const Type& prop, Type * retVal) const
	{
		assert(InsideApartment());

		if(retVal == NULL)
			return E_POINTER;

		*retVal = prop;
		return S_OK;
	}

	/* Events */
	MSTSCLib::IMsTscAxEvents ** GetSinks() const
	{
		if(m_EventSinksCount > 1)
			return m_EventSinks;
		else
			return const_cast<MSTSCLib::IMsTscAxEvents **>(m_EventSinksStatic);
	}

	// Event freezing
	void UnfreezeEvents()
	{
		// Just in case
	}

	// Generic event riser & helpers
	void InvokeSinks(DISPID eventId, VARIANTARG rgvarg[], unsigned int cArgs, VARIANTARG * retval)
	{
		assert(InsideApartment());

		DISPPARAMS params;

		params.rgvarg = rgvarg;
		params.rgdispidNamedArgs = NULL;
		params.cArgs = cArgs;