// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2005 Novell, Inc. (http://www.novell.com)
//
// Authors:
//	Peter Bartok	(pbartok@novell.com)
//	Srikanth Madikeri	(csri_1986@yahoo.com) - Win32 Drop files.
// 

// NOT COMPLETE

using System;
using System.Collections;
using System.Drawing;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Text;

namespace System.Windows.Forms {
	internal class Win32DnD {
		#region Local Variables
		private const uint DATADIR_GET			= 1;
		private const uint S_OK				= 0x00000000;
		private const uint S_FALSE			= 0x00000001;
		private const uint DRAGDROP_S_DROP		= 0x00040100;
		private const uint DRAGDROP_S_CANCEL		= 0x00040101;
		private const uint DRAGDROP_S_USEDEFAULTCURSORS	= 0x00040102;
		private const uint E_NOTIMPL			= unchecked((uint)0x80004001);
		private const uint E_NOINTERFACE		= unchecked((uint)0x80004002);
		private const uint E_FAIL			= unchecked((uint)0x80004005);
		private const uint OLE_E_ADVISENOTSUPPORTED	= unchecked((uint)0x80040003);
		private const uint DV_E_FORMATETC		= unchecked((uint)0x80040064);

		// To call function pointers
		//private static object[]				GetDataArgs;

		// IDataObject Delegates
		private static QueryInterfaceDelegate		DOQueryInterface;
		private static AddRefDelegate			DOAddRef;
		private static ReleaseDelegate			DORelease;
		private static GetDataDelegate			GetData;
		private static GetDataHereDelegate		GetDataHere;
		private static QueryGetDataDelegate		QueryGetData;
		private static GetCanonicalFormatEtcDelegate	GetCanonicalFormatEtc;
		private static SetDataDelegate			SetData;
		private static EnumFormatEtcDelegate		EnumFormatEtc;
		private static DAdviseDelegate			DAdvise;
		private static DUnadviseDelegate		DUnadvise;
		private static EnumDAdviseDelegate		EnumDAdvise;

		// IDropSource Delegates
		private static QueryInterfaceDelegate		DSQueryInterface;
		private static AddRefDelegate			DSAddRef;
		private static ReleaseDelegate			DSRelease;
		private static QueryContinueDragDelegate	QueryContinueDrag;
		private static GiveFeedbackDelegate		GiveFeedback;

		// IDropTarget Delegates
		private static QueryInterfaceDelegate		DTQueryInterface;
		private static AddRefDelegate			DTAddRef;
		private static ReleaseDelegate			DTRelease;
		private static DragEnterDelegate		DragEnter;
		private static DragOverDelegate			DragOver;
		private static DragLeaveDelegate		DragLeave;
		private static DropDelegate			Drop;

		private static DragEventArgs			DragDropEventArgs;
		private static GiveFeedbackEventArgs		DragFeedbackEventArgs;
		private static QueryContinueDragEventArgs	DragContinueEventArgs;
		private static ArrayList			DragFormats;
		private static FORMATETC[]			DragFormatArray;
		private static ArrayList			DragMediums;
		#endregion	// Local Variables

		#region	Delegate Definitions
		// IUnknown
		internal delegate uint QueryInterfaceDelegate(IntPtr @this, ref Guid riid, IntPtr ppvObject);
		internal delegate uint AddRefDelegate(IntPtr @this);
		internal delegate uint ReleaseDelegate(IntPtr @this);

		// IDataObject
		internal delegate uint GetDataDelegate(IntPtr @this, ref FORMATETC pformatetcIn, IntPtr pmedium);
		internal delegate uint GetDataHereDelegate(IntPtr @this, ref FORMATETC pformatetc, ref STGMEDIUM pmedium);
		internal delegate uint QueryGetDataDelegate(IntPtr @this, ref FORMATETC pformatetc);
		internal delegate uint GetCanonicalFormatEtcDelegate(IntPtr @this, ref FORMATETC pformatetcIn, IntPtr pformatetcOut);
		internal delegate uint SetDataDelegate(IntPtr @this, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, bool release);
		internal delegate uint EnumFormatEtcDelegate(IntPtr @this, uint direction, IntPtr ppenumFormatEtc);
		internal delegate uint DAdviseDelegate(IntPtr @this, ref FORMATETC pformatetc, uint advf, IntPtr pAdvSink, ref uint pdwConnection);
		internal delegate uint DUnadviseDelegate(IntPtr @this, uint pdwConnection);
		internal delegate uint EnumDAdviseDelegate(IntPtr @this, IntPtr ppenumAdvise);

		// IDropSource
		internal delegate uint QueryContinueDragDelegate(IntPtr @this, bool fEscapePressed, uint grfkeyState);
		internal delegate uint GiveFeedbackDelegate(IntPtr @this, uint pdwEffect);

		// IDropTarget
		internal delegate uint DragEnterDelegate(IntPtr @this, IntPtr pDataObj, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect);
		internal delegate uint DragOverDelegate(IntPtr @this, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect);
		internal delegate uint DragLeaveDelegate(IntPtr @this);
		internal delegate uint DropDelegate(IntPtr @this, IntPtr pDataObj, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect);
		#endregion	// Delegate Definitions

		[StructLayout(LayoutKind.Sequential)]
			internal struct FORMATETC {
			[MarshalAs(UnmanagedType.U2)]
			internal ClipboardFormats	cfFormat;
			internal IntPtr			ptd;
			internal DVASPECT		dwAspect;
			internal int			lindex;
			internal TYMED			tymed;
		}

		[StructLayout(LayoutKind.Sequential)]
		internal struct STGMEDIUM {
			internal TYMED		tymed;
			internal IntPtr		hHandle;
			internal IntPtr		pUnkForRelease;
		}

		[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
		internal struct DROPFILES { 
			internal uint		pFiles;
			internal uint		pt_x;
			internal uint		pt_y;
			internal bool		fNC;
			internal bool		fWide;
			internal string		pText;
		}

		internal enum DVASPECT {
			DVASPECT_CONTENT	= 1,
			DVASPECT_THUMBNAIL	= 2,
			DVASPECT_ICON		= 4,
			DVASPECT_DOCPRINT	= 8
		}

		internal enum TYMED {
			TYMED_HGLOBAL		= 1,
			TYMED_FILE		= 2,
			TYMED_ISTREAM		= 4,
			TYMED_ISTORAGE		= 8,
			TYMED_GDI		= 16,
			TYMED_MFPICT		= 32,
			TYMED_ENHMF		= 64,
			TYMED_NULL		= 0
		}

		private static readonly Guid IID_IUnknown = new Guid("00000000-0000-0000-C000-000000000046");
		private static readonly Guid IID_IDataObject = new Guid("0000010e-0000-0000-C000-000000000046");
		private static readonly Guid IID_IDropSource = new Guid("00000121-0000-0000-C000-000000000046");
		private static readonly Guid IID_IDropTarget = new Guid("00000122-0000-0000-C000-000000000046");

		static Win32DnD()
		{
			// Required for all other OLE functions to work
			Win32OleInitialize(IntPtr.Zero);

			// We reuse those
			DragDropEventArgs = new DragEventArgs(new DataObject(DataFormats.FileDrop, new string[0]), 0, 0, 0, DragDropEffects.None, DragDropEffects.None);
			DragFeedbackEventArgs = new GiveFeedbackEventArgs(DragDropEffects.None, true);
			DragContinueEventArgs = new QueryContinueDragEventArgs(0, false, DragAction.Continue);
			DragFormats = new ArrayList();
			DragFormatArray = new FORMATETC[0];
			DragMediums = new ArrayList();

			// Set up delegates
			// IDataObject
			DOQueryInterface = new QueryInterfaceDelegate(ComIDataObject.QueryInterface);
			DOAddRef = new AddRefDelegate(ComIDataObject.AddRef);
			DORelease = new ReleaseDelegate(ComIDataObject.Release);
			GetData = new GetDataDelegate(ComIDataObject.GetData);
			GetDataHere = new GetDataHereDelegate(ComIDataObject.GetDataHere);
			QueryGetData = new QueryGetDataDelegate(ComIDataObject.QueryGetData);
			GetCanonicalFormatEtc = new GetCanonicalFormatEtcDelegate(ComIDataObject.GetCanonicalFormatEtc);
			SetData = new SetDataDelegate(ComIDataObject.SetData);
			EnumFormatEtc = new EnumFormatEtcDelegate(ComIDataObject.EnumFormatEtc);
			DAdvise = new DAdviseDelegate(ComIDataObject.DAdvise);
			DUnadvise = new DUnadviseDelegate(ComIDataObject.DUnadvise);
			EnumDAdvise = new EnumDAdviseDelegate(ComIDataObject.EnumDAdvise);

			// IDropSource
			DSQueryInterface = new QueryInterfaceDelegate(ComIDropSource.QueryInterface);
			DSAddRef = new AddRefDelegate(ComIDropSource.AddRef);
			DSRelease = new ReleaseDelegate(ComIDropSource.Release);
			QueryContinueDrag = new QueryContinueDragDelegate(ComIDropSource.QueryContinueDrag);
			GiveFeedback = new GiveFeedbackDelegate(ComIDropSource.GiveFeedback);

			// IDropTarget
			DTQueryInterface = new QueryInterfaceDelegate(ComIDropTarget.QueryInterface);
			DTAddRef = new AddRefDelegate(ComIDropTarget.AddRef);
			DTRelease = new ReleaseDelegate(ComIDropTarget.Release);
			DragEnter = new DragEnterDelegate(ComIDropTarget.DragEnter);
			DragOver = new DragOverDelegate(ComIDropTarget.DragOver);
			DragLeave = new DragLeaveDelegate(ComIDropTarget.DragLeave);
			Drop = new DropDelegate(ComIDropTarget.Drop);
		}

		internal class ComIDataObject {
			[StructLayout(LayoutKind.Sequential)]
			internal struct DataObjectStruct {
				internal IntPtr				vtbl;
				internal QueryInterfaceDelegate		QueryInterface;
				internal AddRefDelegate			AddRef;
				internal ReleaseDelegate		Release;
				internal GetDataDelegate		GetData;
				internal GetDataHereDelegate		GetDataHere;
				internal QueryGetDataDelegate		QueryGetData;
				internal GetCanonicalFormatEtcDelegate	GetCanonicalFormatEtc;
				internal SetDataDelegate		SetData;
				internal EnumFormatEtcDelegate		EnumFormatEtc;
				internal DAdviseDelegate		DAdvise;
				internal DUnadviseDelegate		DUnadvise;
				internal EnumDAdviseDelegate		EnumDAdvise;
			}

			internal static IntPtr GetUnmanaged() {
				DataObjectStruct	data_object;
				IntPtr			data_object_ptr;
				long			offset;

				data_object = new DataObjectStruct();

				data_object.QueryInterface = Win32DnD.DOQueryInterface;
				data_object.AddRef = Win32DnD.DOAddRef;
				data_object.Release = Win32DnD.DORelease;
				data_object.GetData = Win32DnD.GetData;
				data_object.GetDataHere = Win32DnD.GetDataHere;
				data_object.QueryGetData = Win32DnD.QueryGetData;
				data_object.GetCanonicalFormatEtc = Win32DnD.GetCanonicalFormatEtc;
				data_object.SetData = Win32DnD.SetData;
				data_object.EnumFormatEtc = Win32DnD.EnumFormatEtc;
				data_object.DAdvise = Win32DnD.DAdvise;
				data_object.DUnadvise = Win32DnD.DUnadvise;
				data_object.EnumDAdvise = Win32DnD.EnumDAdvise;

				data_object_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(DataObjectStruct)));
				Marshal.StructureToPtr(data_object, data_object_ptr, false);

				// Update vtbl pointer
				offset = data_object_ptr.ToInt64();
				offset += Marshal.SizeOf(typeof(IntPtr));
				Marshal.WriteIntPtr(data_object_ptr, new IntPtr(offset));
				
				return data_object_ptr;
			}

			internal static void ReleaseUnmanaged(IntPtr data_object_ptr) {
				Marshal.FreeHGlobal(data_object_ptr);
			}

			internal static uint QueryInterface(IntPtr @this, ref Guid riid, IntPtr ppvObject) {
				try {
					if (IID_IUnknown.Equals(riid) || IID_IDataObject.Equals(riid)) {
						Marshal.WriteIntPtr(ppvObject, @this);
						return S_OK;
					}
				}

				catch (Exception e) {
					Console.WriteLine("Got exception {0}", e.Message);
				}

				Marshal.WriteIntPtr(ppvObject, IntPtr.Zero);
				return E_NOINTERFACE;
			}

			internal static uint AddRef(IntPtr @this) {
				// We only use this for DnD, try and fake it
				return 1;
			}

			internal static uint Release(IntPtr @this) {
				// We only use this for DnD, try and fake it
				return 0;
			}

			internal static 	STGMEDIUM	medium = new STGMEDIUM();
			internal static uint GetData(IntPtr this_, ref FORMATETC pformatetcIn, IntPtr pmedium) {
				int		index;

				index = FindFormat(pformatetcIn);
				if (index != -1) {
					medium.tymed = TYMED.TYMED_HGLOBAL;
					medium.hHandle = XplatUIWin32.DupGlobalMem(((STGMEDIUM)DragMediums[index]).hHandle);
					medium.pUnkForRelease = IntPtr.Zero;
					try {
						Marshal.StructureToPtr(medium, pmedium, false);
					}
					catch (Exception e) {
						Console.WriteLine("Error: {0}", e.Message);
					}
					return S_OK;
				}

				return DV_E_FORMATETC;
			}

			internal static uint GetDataHere(IntPtr @this, ref FORMATETC pformatetc, ref STGMEDIUM pmedium) {
				return DV_E_FORMATETC;
			}

			internal static uint QueryGetData(IntPtr @this, ref FORMATETC pformatetc) {
				if (FindFormat(pformatetc) != -1) {
					return S_OK;
				}
				return DV_E_FORMATETC;
			}

			internal static uint GetCanonicalFormatEtc(IntPtr @this, ref FORMATETC pformatetcIn, IntPtr pformatetcOut) {
				Marshal.WriteIntPtr(pformatetcOut, Marshal.SizeOf(typeof(IntPtr)), IntPtr.Zero);
				return E_NOTIMPL;
			}

			internal static uint SetData(IntPtr this_, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, bool release) {
				return E_NOTIMPL;
			}

			internal static uint EnumFormatEtc(IntPtr this_, uint direction, IntPtr ppenumFormatEtc) {
				if (direction == DATADIR_GET) {
					IntPtr	ppenum_ptr;

					ppenum_ptr = IntPtr.Zero;
					DragFormatArray = new FORMATETC[DragFormats.Count];

					for (int i = 0; i < DragFormats.Count; i++) {
						DragFormatArray[i] = (FORMATETC)DragFormats[i];
					}
					Win32SHCreateStdEnumFmtEtc((uint)DragFormatArray.Length, DragFormatArray, ref ppenum_ptr);
					Marshal.WriteIntPtr(ppenumFormatEtc, ppenum_ptr);
					return S_OK;
				}
				return E_NOTIMPL;
			}

			internal static uint DAdvise(IntPtr this_, ref FORMATETC pformatetc, uint advf, IntPtr pAdvSink, ref uint pdwConnection) {
				return OLE_E_ADVISENOTSUPPORTED;
			}

			internal static uint DUnadvise(IntPtr this_, uint pdwConnection) {
				return OLE_E_ADVISENOTSUPPORTED;
			}

			internal static uint EnumDAdvise(IntPtr this_, IntPtr ppenumAdvise) {
				return OLE_E_ADVISENOTSUPPORTED;
			}
		}

		internal class ComIDataObjectUnmanaged {
			[StructLayout(LayoutKind.Sequential)]
				internal struct IDataObjectUnmanaged {
				internal IntPtr		QueryInterface;
				internal IntPtr		AddRef;
				internal IntPtr		Release;
				internal IntPtr		GetData;
				internal IntPtr		GetDataHere;
				internal IntPtr		QueryGetData;
				internal IntPtr		GetCanonicalFormatEtc;
				internal IntPtr		SetData;
				internal IntPtr		EnumFormatEtc;
				internal IntPtr		DAdvise;
				internal IntPtr		DUnadvise;
				internal IntPtr		EnumDAdvise;
			}

			private static bool		Initialized;
			private static MethodInfo	GetDataMethod;
			//private static MethodInfo	GetDataHereMethod;
			private static MethodInfo	QueryGetDataMethod;
			//private static MethodInfo	GetCanonicalFormatEtcMethod;
			//private static MethodInfo	SetDataMethod;
			//private static MethodInfo	EnumFormatEtcMethod;
			//private static MethodInfo	DAdviseMethod;
			//private static MethodInfo	DUnadviseMethod;
			//private static MethodInfo	EnumDAdviseMethod;
			private static object[]		MethodArguments;

			private IDataObjectUnmanaged	vtbl;
			private IntPtr			@this;

			internal ComIDataObjectUnmanaged(IntPtr data_object_ptr) {
				if (!Initialized) {
					Initialize();
				}

				vtbl = new IDataObjectUnmanaged();
				@this = data_object_ptr;
				try {
					vtbl = (IDataObjectUnmanaged)Marshal.PtrToStructure(Marshal.ReadIntPtr(data_object_ptr), typeof(IDataObjectUnmanaged));
				}

				catch (Exception e) {
					Console.WriteLine("Exception {0}", e.Message);
				}
			}

			private static void Initialize() {
				AssemblyName	assembly;
				AssemblyBuilder	assembly_builder;

				if (Initialized) {
					return;
				}

				assembly = new AssemblyName();
				assembly.Name = "XplatUIWin32.FuncPtrInterface";
				assembly_builder = AppDomain.CurrentDomain.DefineDynamicAssembly(assembly, AssemblyBuilderAccess.Run);

				MethodArguments = new object[6];
				GetDataMethod = CreateFuncPtrInterface(assembly_builder, "GetData", typeof(uint), 3);
				//GetDataHereMethod = CreateFuncPtrInterface(assembly_builder, "GetDataHere", typeof(uint), 3);
				QueryGetDataMethod = CreateFuncPtrInterface(assembly_builder, "QueryGetData", typeof(uint), 2);
				//GetCanonicalFormatEtcMethod = CreateFuncPtrInterface(assembly_builder, "GetCanonicalFormatEtc", typeof(uint), 3);
				//SetDataMethod = CreateFuncPtrInterface(assembly_builder, "SetData", typeof(uint), 4);
				//EnumFormatEtcMethod = CreateFuncPtrInterface(assembly_builder, "EnumFormatEtc", typeof(uint), 3);
				//DAdviseMethod = CreateFuncPtrInterface(assembly_builder, "DAdvise", typeof(uint), 5);
				//DUnadviseMethod = CreateFuncPtrInterface(assembly_builder, "DUnadvise", typeof(uint), 2);
				//EnumDAdviseMethod = CreateFuncPtrInterface(assembly_builder, "EnumDAdvise", typeof(uint), 2);

				Initialized = true;
			}

			internal uint QueryInterface(Guid riid, IntPtr ppvObject) {
				uint	ret;
				IntPtr	riid_ptr;

				riid_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Guid)));
				Marshal.StructureToPtr(riid, riid_ptr, false);

				MethodArguments[0] = vtbl.QueryInterface;
				MethodArguments[1] = this.@this;
				MethodArguments[2] = riid_ptr;
				MethodArguments[3] = ppvObject;

				try {
					ret = (uint)GetDataMethod.Invoke(null, MethodArguments);
				}

				catch (Exception e) {
					Console.WriteLine("Caught exception {0}", e.Message);
					ret = E_FAIL;
				}

				Marshal.FreeHGlobal(riid_ptr);

				return ret;
			}

			internal uint AddRef() {
				// We only use this for DnD, try and fake it
				return 1;
			}

			internal uint Release() {
				// We only use this for DnD, try and fake it
				return 0;
			}

			internal uint GetData(FORMATETC pformatetcIn, ref STGMEDIUM pmedium) {
				uint	ret;
				IntPtr	pformatetcIn_ptr;
				IntPtr	pmedium_ptr;

				pformatetcIn_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(FORMATETC)));
				Marshal.StructureToPtr(pformatetcIn, pformatetcIn_ptr, false);

				pmedium_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(STGMEDIUM)));

				MethodArguments[0] = vtbl.GetData;
				MethodArguments[1] = this.@this;
				MethodArguments[2] = pformatetcIn_ptr;
				MethodArguments[3] = pmedium_ptr;

				try {
					ret = (uint)GetDataMethod.Invoke(null, MethodArguments);
					Marshal.PtrToStructure(pmedium_ptr, pmedium);
				}

				catch (Exception e) {
					Console.WriteLine("Caught exception {0}", e.Message);
					ret = E_FAIL;
				}

				Marshal.FreeHGlobal(pformatetcIn_ptr);
				Marshal.FreeHGlobal(pmedium_ptr);

				return ret;
			}

			internal uint GetDataHere(FORMATETC pformatetc, ref STGMEDIUM pmedium) {
				return E_NOTIMPL;
			}

			internal uint QueryGetData(FORMATETC pformatetc) {
				uint	ret;
				IntPtr	pformatetc_ptr;

				pformatetc_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(FORMATETC)));
				Marshal.StructureToPtr(pformatetc, pformatetc_ptr, false);

				MethodArguments[0] = vtbl.GetData;
				MethodArguments[1] = this.@this;
				MethodArguments[2] = pformatetc_ptr;

				try {
					ret = (uint)QueryGetDataMethod.Invoke(null, MethodArguments);
				}

				catch (Exception e) {
					Console.WriteLine("Caught exception {0}", e.Message);
					ret = E_FAIL;
				}

				Marshal.FreeHGlobal(pformatetc_ptr);

				return ret;
			}

			internal uint GetCanonicalFormatEtc(FORMATETC pformatetcIn, ref FORMATETC pformatetcOut) {
				return E_NOTIMPL;
			}

			internal uint SetData(FORMATETC pformatetc, STGMEDIUM pmedium, bool release) {
				return E_NOTIMPL;
			}

			internal uint EnumFormatEtc(uint direction, IntPtr ppenumFormatEtc) {
				return E_NOTIMPL;
			}

			internal uint DAdvise(FORMATETC pformatetc, uint advf, IntPtr pAdvSink, ref uint pdwConnection) {
				return OLE_E_ADVISENOTSUPPORTED;
			}

			internal uint DUnadvise(uint pdwConnection) {
				return OLE_E_ADVISENOTSUPPORTED;
			}

			internal uint EnumDAdvise(IntPtr ppenumAdvise) {
				return OLE_E_ADVISENOTSUPPORTED;
			}
		}


		internal class ComIDropSource {
			[StructLayout(LayoutKind.Sequential)]
				internal struct IDropSource {
				internal IntPtr				vtbl;
				internal IntPtr				Window;
				internal QueryInterfaceDelegate		QueryInterface;
				internal AddRefDelegate			AddRef;
				internal ReleaseDelegate		Release;
				internal QueryContinueDragDelegate	QueryContinueDrag;
				internal GiveFeedbackDelegate		GiveFeedback;
			}

			internal static IntPtr GetUnmanaged(IntPtr Window) {
				IDropSource	drop_source;
				IntPtr		drop_source_ptr;
				long		offset;

				drop_source = new IDropSource();
				drop_source.QueryInterface = Win32DnD.DSQueryInterface;
				drop_source.AddRef = Win32DnD.DSAddRef;
				drop_source.Release = Win32DnD.DSRelease;
				drop_source.QueryContinueDrag = Win32DnD.QueryContinueDrag;
				drop_source.GiveFeedback = Win32DnD.GiveFeedback;
				drop_source.Window = Window;

				drop_source_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(drop_source));
				Marshal.StructureToPtr(drop_source, drop_source_ptr, false);

				// Update vtbl pointer
				offset = drop_source_ptr.ToInt64();
				offset += 2 * Marshal.SizeOf(typeof(IntPtr));
				Marshal.WriteIntPtr(drop_source_ptr, new IntPtr(offset));
				
				return drop_source_ptr;
			}

			internal static void ReleaseUnmanaged(IntPtr drop_source_ptr) {
				Marshal.FreeHGlobal(drop_source_ptr);
			}

			internal static uint QueryInterface(IntPtr @this, ref Guid riid, IntPtr ppvObject) {
				try {
					if (IID_IUnknown.Equals(riid) || IID_IDropSource.Equals(riid)) {
						Marshal.WriteIntPtr(ppvObject, @this);
						return S_OK;
					}
				}

				catch (Exception e) {
					Console.WriteLine("Got exception {0}", e.Message);
				}

				Marshal.WriteIntPtr(ppvObject, IntPtr.Zero);
				return E_NOINTERFACE;
			}

			internal static uint AddRef(IntPtr @this) {
				// We only use this for DnD, try and fake it
				return 1;
			}

			internal static uint Release(IntPtr @this) {
				// We only use this for DnD, try and fake it
				return 0;
			}

			internal static uint QueryContinueDrag(IntPtr @this, bool fEscapePressed, uint grfkeyState) {
				IntPtr		window;

				window = Marshal.ReadIntPtr(@this, Marshal.SizeOf(typeof(IntPtr)));

				// LAMESPEC? - according to MSDN, when the any mousebutton is *pressed* it defaults to Drop.
				// According to COM customary behaviour it's the other way round; which is what we do here
				if (fEscapePressed) {
					DragContinueEventArgs.drag_action = DragAction.Cancel;
				} else if ((grfkeyState & (1+2+16)) == 0) {		// Left, middle and right mouse button not pressed
					DragContinueEventArgs.drag_action = DragAction.Drop;
				} else {
					DragContinueEventArgs.drag_action = DragAction.Continue;
				}

				DragContinueEventArgs.escape_pressed = fEscapePressed;
				DragContinueEventArgs.key_state = (int)grfkeyState;

				Control.FromHandle(window).DndContinueDrag(DragContinueEventArgs);

				if (DragContinueEventArgs.drag_action == DragAction.Cancel) {
					return DRAGDROP_S_CANCEL;
				} else if (DragContinueEventArgs.drag_action == DragAction.Drop) {
					return DRAGDROP_S_DROP;
				}
				return S_OK;
			}

			internal static uint GiveFeedback(IntPtr @this, uint pdwEffect) {
				IntPtr		window;

				window = Marshal.ReadIntPtr(@this, Marshal.SizeOf(typeof(IntPtr)));

				DragFeedbackEventArgs.effect = (DragDropEffects)pdwEffect;
				DragFeedbackEventArgs.use_default_cursors = true;

				Control.FromHandle(window).DndFeedback(DragFeedbackEventArgs);

				if (DragFeedbackEventArgs.use_default_cursors) {
					return DRAGDROP_S_USEDEFAULTCURSORS;
				}
				return S_OK;
			}
		}

		internal class ComIDropTarget {
			[StructLayout(LayoutKind.Sequential)]
				internal struct IDropTarget {
				internal IntPtr				vtbl;
				internal IntPtr				Window;
				internal QueryInterfaceDelegate		QueryInterface;
				internal AddRefDelegate			AddRef;
				internal ReleaseDelegate		Release;

				internal DragEnterDelegate		DragEnter;
				internal DragOverDelegate		DragOver;
				internal DragLeaveDelegate		DragLeave;
				internal DropDelegate			Drop;
			}

			internal static IntPtr GetUnmanaged(IntPtr Window) {
				IDropTarget	drop_target;
				IntPtr		drop_target_ptr;
				long		offset;

				drop_target = new IDropTarget();
				drop_target.QueryInterface = Win32DnD.DTQueryInterface;
				drop_target.AddRef = Win32DnD.DTAddRef;
				drop_target.Release = Win32DnD.DTRelease;
				drop_target.DragEnter = Win32DnD.DragEnter;
				drop_target.DragOver = Win32DnD.DragOver;
				drop_target.DragLeave = Win32DnD.DragLeave;
				drop_target.Drop = Win32DnD.Drop;
				drop_target.Window = Window;

				drop_target_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(drop_target));
				Marshal.StructureToPtr(drop_target, drop_target_ptr, false);

				// Update vtbl pointer
				offset = drop_target_ptr.ToInt64();
				offset += 2 * Marshal.SizeOf(typeof(IntPtr));
				Marshal.WriteIntPtr(drop_target_ptr, new IntPtr(offset));
				
				return drop_target_ptr;
			}

			internal static void ReleaseUnmanaged(IntPtr drop_target_ptr) {
				Marshal.FreeHGlobal(drop_target_ptr);
			}

			internal static uint QueryInterface(IntPtr @this, ref Guid riid, IntPtr ppvObject) {
				try {
					if (IID_IUnknown.Equals(riid) || IID_IDropTarget.Equals(riid)) {
						Marshal.WriteIntPtr(ppvObject, @this);
						return S_OK;
					}
				}

				catch (Exception e) {
					Console.WriteLine("Got exception {0}", e.Message);
				}

				Marshal.WriteIntPtr(ppvObject, IntPtr.Zero);
				return E_NOINTERFACE;
			}

			internal static uint AddRef(IntPtr @this) {
				// We only use this for DnD, try and fake it
				return 1;
			}

			internal static uint Release(IntPtr @this) {
				// We only use this for DnD, try and fake it
				return 0;
			}

			internal static uint DragEnter(IntPtr @this, IntPtr pDataObj, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect) {
				IntPtr		window;

				window = Marshal.ReadIntPtr(@this, Marshal.SizeOf(typeof(IntPtr)));

				DragDropEventArgs.x = pt_x.ToInt32();
				DragDropEventArgs.y = pt_y.ToInt32();
				DragDropEventArgs.allowed_effect = (DragDropEffects)Marshal.ReadIntPtr(pdwEffect).ToInt32();
				DragDropEventArgs.current_effect = DragDropEventArgs.AllowedEffect;
				DragDropEventArgs.keystate = (int)grfkeyState;

				Control.FromHandle(window).DndEnter(DragDropEventArgs);

				Marshal.WriteInt32(pdwEffect, (int)DragDropEventArgs.Effect);

				return S_OK;
			}

			internal static uint DragOver(IntPtr @this, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect) {
				IntPtr window;

				window = Marshal.ReadIntPtr(@this, Marshal.SizeOf(typeof(IntPtr)));

				DragDropEventArgs.x = pt_x.ToInt32();
				DragDropEventArgs.y = pt_y.ToInt32();
				DragDropEventArgs.allowed_effect = (DragDropEffects)Marshal.ReadIntPtr(pdwEffect).ToInt32();
				DragDropEventArgs.current_effect = DragDropEventArgs.AllowedEffect;
				DragDropEventArgs.keystate = (int)grfkeyState;

				Control.FromHandle(window).DndOver(DragDropEventArgs);

				Marshal.WriteInt32(pdwEffect, (int)DragDropEventArgs.Effect);

				return S_OK;
			}

			internal static uint DragLeave(IntPtr @this) {
				IntPtr window;

				window = Marshal.ReadIntPtr(@this, Marshal.SizeOf(typeof(IntPtr)));

				Control.FromHandle(window).DndLeave(EventArgs.Empty);

				return S_OK;
			}

			internal static uint Drop(IntPtr @this, IntPtr pDataObj, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect)
			{
		  		IntPtr window;
				
				window = Marshal.ReadIntPtr (@this, Marshal.SizeOf (typeof (IntPtr)));

				DragDropEventArgs.x = pt_x.ToInt32 ();
				DragDropEventArgs.y = pt_y.ToInt32 ();
				DragDropEventArgs.allowed_effect = (DragDropEffects) Marshal.ReadIntPtr (pdwEffect).ToInt32();
				DragDropEventArgs.current_effect = DragDropEventArgs.AllowedEffect;
				DragDropEventArgs.keystate = (int) grfkeyState;

				Control control = Control.FromHandle (window);
				if (control != null) {
					control.DndDrop (DragDropEventArgs);
					return S_FALSE;
				}
 
				Marshal.WriteInt32 (pdwEffect, (int) DragDropEventArgs.Effect);

				return S_OK;
			}
		}

		internal static bool HandleWMDropFiles(ref MSG msg) {
			IntPtr		hDrop;
			int		count;
			StringBuilder	sb;
			string[]	dropfiles;

			hDrop = msg.wParam;
			count = Win32DragQueryFile(hDrop, -1, IntPtr.Zero, 0);

			dropfiles = new string[count];

			sb = new StringBuilder(256);
			for (int i = 0; i < count; i++) {
				Win32DragQueryFile(hDrop, i, sb, sb.Capacity);
				dropfiles[i] = sb.ToString();
			}

			DragDropEventArgs.Data.SetData(DataFormats.FileDrop, dropfiles);

			Control.FromHandle(msg.hwnd).DndDrop(DragDropEventArgs);

			return true;
		}

		private static bool AddFormatAndMedium(ClipboardFormats cfFormat, object data) {
			STGMEDIUM	medium;
			FORMATETC	format;
			IntPtr		hmem;
			IntPtr		hmem_ptr;
			byte[]		b;

			switch(cfFormat) {
				case ClipboardFormats.CF_TEXT: {
					b = XplatUIWin32.StringToAnsi ((string)data);
					hmem = XplatUIWin32.CopyToMoveableMemory (b);
					break;
				}

				case ClipboardFormats.CF_UNICODETEXT: {
					b = XplatUIWin32.StringToUnicode ((string)data);
					hmem = XplatUIWin32.CopyToMoveableMemory (b);
					break;
				}

				case ClipboardFormats.CF_HDROP: {
					IEnumerator	e;
					StringBuilder	sb;
					long		hmem_string_ptr;
					IntPtr		string_buffer;
					int		string_buffer_size;

					sb = new StringBuilder();

					// Make sure object is enumerable; otherwise
					if ((data is string) || !(data is IEnumerable)) {
						sb.Append(data.ToString());
						sb.Append('\0');
						sb.Append('\0');
					} else {
						e = ((IEnumerable)data).GetEnumerator();
						while (e.MoveNext()) {
							sb.Append(e.Current.ToString());
							sb.Append('\0');
						}
						sb.Append('\0');
					}

					string_buffer = Marshal.StringToHGlobalUni(sb.ToString());
					string_buffer_size = (int)XplatUIWin32.Win32GlobalSize(string_buffer);

					// Write DROPFILES structure
					hmem = XplatUIWin32.Win32GlobalAlloc(XplatUIWin32.GAllocFlags.GMEM_MOVEABLE | XplatUIWin32.GAllocFlags.GMEM_DDESHARE, 0x14 + string_buffer_size);
					hmem_ptr = XplatUIWin32.Win32GlobalLock(hmem);
					Marshal.WriteInt32(hmem_ptr, 0x14);					// pFiles
					Marshal.WriteInt32(hmem_ptr, 1 * Marshal.SizeOf(typeof(uint)), 0);	// point.x
					Marshal.WriteInt32(hmem_ptr, 2 * Marshal.SizeOf(typeof(uint)), 0);	// point.y
					Marshal.WriteInt32(hmem_ptr, 3 * Marshal.SizeOf(typeof(uint)), 0);	// fNc
					Marshal.WriteInt32(hmem_ptr, 4 * Marshal.SizeOf(typeof(uint)), 1);	// fWide

					hmem_string_ptr = (long)hmem_ptr;
					hmem_string_ptr += 0x14;

					XplatUIWin32.Win32CopyMemory(new IntPtr(hmem_string_ptr), string_buffer, string_buffer_size);
					Marshal.FreeHGlobal(string_buffer);
					XplatUIWin32.Win32GlobalUnlock(hmem_ptr);

					break;
				}

				case ClipboardFormats.CF_DIB: {
					b = XplatUIWin32.ImageToDIB((Image)data);
					hmem = XplatUIWin32.CopyToMoveableMemory (b);
					break;
				}

				default: {
					hmem = IntPtr.Zero;
					break;
				}
			}

			if (hmem != IntPtr.Zero) {
				medium = new STGMEDIUM();
				medium.tymed = TYMED.TYMED_HGLOBAL;
				medium.hHandle = hmem;
				medium.pUnkForRelease = IntPtr.Zero;
				DragMediums.Add(medium);

				format = new FORMATETC();
				format.ptd = IntPtr.Zero;
				format.dwAspect = DVASPECT.DVASPECT_CONTENT;
				format.lindex = -1;
				format.tymed = TYMED.TYMED_HGLOBAL;
				format.cfFormat = cfFormat;
				DragFormats.Add(format);

				return true;
			}

			return false;
		}

		private static int FindFormat(FORMATETC pformatetc) {
			for (int i = 0; i < DragFormats.Count; i++) {
				if ((((FORMATETC)DragFormats[i]).cfFormat == pformatetc.cfFormat) &&
					(((FORMATETC)DragFormats[i]).dwAspect  == pformatetc.dwAspect) &&
					((((FORMATETC)DragFormats[i]).tymed & pformatetc.tymed)) != 0) {
					return i;
				}
			}
			return -1;
		}

		private static void BuildFormats(object data) {

			DragFormats.Clear();
			DragMediums.Clear();

			// Build our formats based on object data
			if (data is String) {
				AddFormatAndMedium(ClipboardFormats.CF_TEXT, data);
				AddFormatAndMedium(ClipboardFormats.CF_UNICODETEXT, data);
				AddFormatAndMedium(ClipboardFormats.CF_HDROP, data);
			} else if (data is Bitmap) {
				AddFormatAndMedium(ClipboardFormats.CF_DIB, data);
			} else if (data is ICollection) {
				// FIXME - test with .Net and found how this is handled
				AddFormatAndMedium(ClipboardFormats.CF_HDROP, data);
			} else if (data is ISerializable) {
				// FIXME - test with .Net and found how this is handled
			}
		}

		internal static DragDropEffects StartDrag(IntPtr Window, object data, DragDropEffects allowed) {
			IntPtr	result;
			IntPtr	data_object;
			IntPtr	drop_source;

			BuildFormats(data);

			data_object = ComIDataObject.GetUnmanaged();
			drop_source = ComIDropSource.GetUnmanaged(Window);

			result = (IntPtr)DragDropEffects.None;

			Win32DoDragDrop(data_object, drop_source, (IntPtr)allowed, ref result);

			// Cleanup again
			ComIDataObject.ReleaseUnmanaged(data_object);
			ComIDropSource.ReleaseUnmanaged(drop_source);
			DragFormats.Clear();
			DragFormatArray = null;
			DragMediums.Clear();

			return (DragDropEffects)result.ToInt32();
		}

		internal static bool UnregisterDropTarget(IntPtr Window) {
			Win32RevokeDragDrop(Window);
			return true;
		}

		internal static bool RegisterDropTarget(IntPtr Window) {
			Hwnd	hwnd;
			IntPtr	drop_target;
			uint	result;

			hwnd = Hwnd.ObjectFromWindow(Window);
			if (hwnd == null) {
				return false;
			}

			drop_target = ComIDropTarget.GetUnmanaged(Window);
			hwnd.marshal_free_list.Add(drop_target);
			result = Win32RegisterDragDrop(Window, drop_target);

			if (result != S_OK) {
				return false;
			}
			return true;
		}

		// Thanks, Martin
		static MethodInfo CreateFuncPtrInterface(AssemblyBuilder assembly, string MethodName, Type ret_type, int param_count) {
			ModuleBuilder	mb;
			TypeBuilder	tb;
			Type[]		il_param_types;
			Type[]		param_types;

			mb = assembly.DefineDynamicModule("XplatUIWin32.FuncInterface" + MethodName);
			tb = mb.DefineType ("XplatUIWin32.FuncInterface" + MethodName, TypeAttributes.Public);

			param_types = new Type[param_count];
			il_param_types = new Type[param_count + 1];

			il_param_types[param_count] = typeof(IntPtr);
			for (int i = 0; i < param_count; i++) {
				param_types[i] = typeof(IntPtr);
				il_param_types[i] = typeof(IntPtr);
			}

			MethodBuilder method = tb.DefineMethod (
				MethodName, MethodAttributes.Static | MethodAttributes.Public,
				ret_type, il_param_types);

			ILGenerator ig = method.GetILGenerator ();
			if (param_count > 5) ig.Emit (OpCodes.Ldarg_S, 6);
			if (param_count > 4) ig.Emit (OpCodes.Ldarg_S, 5);
			if (param_count > 3) ig.Emit (OpCodes.Ldarg_S, 4);
			if (param_count > 2) ig.Emit (OpCodes.Ldarg_3);
			if (param_count > 1) ig.Emit (OpCodes.Ldarg_2);
			if (param_count > 0) ig.Emit (OpCodes.Ldarg_1);
			ig.Emit (OpCodes.Ldarg_0);
			ig.EmitCalli (OpCodes.Calli, CallingConvention.StdCall, ret_type, param_types);
			ig.Emit (OpCodes.Ret);

			Type t = tb.CreateType ();
			MethodInfo m = t.GetMethod (MethodName);

			return m;
		}

		[DllImport ("ole32.dll", EntryPoint="RegisterDragDrop", CallingConvention=CallingConvention.StdCall)]
		private extern static uint Win32RegisterDragDrop(IntPtr Window, IntPtr pDropTarget);

		[DllImport ("ole32.dll", EntryPoint="RevokeDragDrop", CallingConvention=CallingConvention.StdCall)]
		private extern static int Win32RevokeDragDrop(IntPtr Window);

		[DllImport ("ole32.dll", EntryPoint="DoDragDrop", CallingConvention=CallingConvention.StdCall)]
		private extern static uint Win32DoDragDrop(IntPtr pDataObject, IntPtr pDropSource, IntPtr dwOKEffect, ref IntPtr pdwEffect);

		//[DllImport ("shell32.dll", EntryPoint="DragAcceptFiles", CallingConvention=CallingConvention.StdCall)]
		//private extern static int Win32DragAcceptFiles(IntPtr Window, bool fAccept);

		[DllImport ("ole32.dll", EntryPoint="OleInitialize", CallingConvention=CallingConvention.StdCall)]
		private extern static int Win32OleInitialize(IntPtr pvReserved);

		[DllImport ("shell32.dll", EntryPoint="DragQueryFileW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)]
		private extern static int Win32DragQueryFile(IntPtr hDrop, int iFile, IntPtr lpszFile, int cch);

		[DllImport ("shell32.dll", EntryPoint="DragQueryFileW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)]
		private extern static int Win32DragQueryFile(IntPtr hDrop, int iFile, StringBuilder lpszFile, int cch);

		[DllImport ("shell32.dll", EntryPoint="SHCreateStdEnumFmtEtc", CallingConvention=CallingConvention.StdCall)]
		private extern static uint Win32SHCreateStdEnumFmtEtc(uint cfmt, FORMATETC[] afmt, ref IntPtr ppenumFormatEtc);
	}
}