1082 lines
36 KiB
C#
1082 lines
36 KiB
C#
// 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);
|
|
}
|
|
}
|