//
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
// Next
int OleInterop.IEnumFORMATETC.Next(uint celt, OleInterop.FORMATETC[] rgelt, uint[] pceltFetched)
{
if (null != oleEnum)
{
return(oleEnum.Next(celt, rgelt, pceltFetched));
}
BclComTypes.FORMATETC[] bclStat = new BclComTypes.FORMATETC[celt];
int[] fetched = new int[1];
int hr = bclEnum.Next((int)celt, bclStat, fetched);
if (NativeMethods.Failed(hr))
{
return(hr);
}
if (null != pceltFetched)
{
pceltFetched[0] = (uint)fetched[0];
}
for (int i = 0; i < fetched[0]; i++)
{
rgelt[i] = StructConverter.BclFormatETC2Ole(ref bclStat[i]);
}
return(hr);
}
int OleInterop.IDataObject.DAdvise(OleInterop.FORMATETC[] pFormatetc, uint ADVF, OleInterop.IAdviseSink pAdvSink, out uint pdwConnection)
{
if (null != oleData)
{
return(oleData.DAdvise(pFormatetc, ADVF, pAdvSink, out pdwConnection));
}
// We have to call the method in the BCL version of the interface, so we need to
// convert the parameters to the other type of structure.
// As first make sure that the array contains exactly one element.
if ((null == pFormatetc) || (pFormatetc.Length != 1))
{
throw new ArgumentException();
}
// Now convert the patameters
BclComTypes.FORMATETC bclFormat = StructConverter.OleFormatETC2Bcl(ref pFormatetc[0]);
BclComTypes.IAdviseSink bclSink = pAdvSink as BclComTypes.IAdviseSink;
if (null == bclSink)
{
bclSink = new AdviseSink(pAdvSink);
}
int connection;
int hr = bclData.DAdvise(ref bclFormat, (BclComTypes.ADVF)(ADVF), bclSink, out connection);
pdwConnection = (uint)connection;
return(hr);
}
//
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
// OnDataChange
//
void IOleAdviseSink.OnDataChange(OleInterop.FORMATETC[] pFormatetc, OleInterop.STGMEDIUM[] pStgmed)
{
if (null != oleSink)
{
oleSink.OnDataChange(pFormatetc, pStgmed);
}
else
{
// In order to call the version of this interface defined in the BCL
// each array must contain exactly one object.
if ((null == pFormatetc) || (null == pStgmed))
{
throw new ArgumentNullException("");
}
if ((1 != pFormatetc.Length) || (1 != pStgmed.Length))
{
throw new InvalidOperationException();
}
// Convert the parameters
BclComTypes.FORMATETC bclFormat = StructConverter.OleFormatETC2Bcl(ref pFormatetc[0]);
BclComTypes.STGMEDIUM bclMedium = StructConverter.OleSTGMEDIUM2Bcl(ref pStgmed[0]);
// Now we can call the method on the BCL interface
bclSink.OnDataChange(ref bclFormat, ref bclMedium);
// Now we have to copy the parameters back into the original structures.
pFormatetc[0] = StructConverter.BclFormatETC2Ole(ref bclFormat);
pStgmed[0] = StructConverter.BclSTGMEDIUM2Ole(ref bclMedium);
}
}
/// <summary>
/// Creates a connection between a data object and an advisory sink. This method is called by an object
/// that supports an advisory sink and enables the advisory sink to be notified of changes in the object's data.</summary>
/// <returns>This method supports the standard return values E_INVALIDARG, E_UNEXPECTED, and E_OUTOFMEMORY,
/// as well as the following:
/// ValueDescriptionS_OK -- The advisory connection was created.
/// E_NOTIMPL -- This method is not implemented on the data object.
/// DV_E_LINDEX -- There is an invalid value for <see cref="F:System.Runtime.InteropServices.ComTypes.FORMATETC.lindex"/>;
/// currently, only -1 is supported.
/// DV_E_FORMATETC -- There is an invalid value for the <paramref name="pFormatetc"/> parameter.
/// OLE_E_ADVISENOTSUPPORTED -- The data object does not support change notification.</returns>
/// <param name="pFormatetc">A <see cref="T:System.Runtime.InteropServices.ComTypes.FORMATETC"/> structure,
/// passed by reference, that defines the format, target device, aspect, and medium that will be used for
/// future notifications.</param>
/// <param name="advf">One of the ADVF values that specifies a group of flags for controlling the advisory
/// connection.</param>
/// <param name="adviseSink">A pointer to the IAdviseSink interface on the advisory sink that will receive
/// the change notification.</param>
/// <param name="connection">When this method returns, contains a pointer to a DWORD token that identifies
/// this connection. You can use this token later to delete the advisory connection by passing it to
/// <see cref="M:System.Runtime.InteropServices.ComTypes.IDataObject.DUnadvise(System.Int32)"/>.
/// If this value is zero, the connection was not established. This parameter is passed uninitialized.</param>
public int DAdvise(ref FORMATETC pFormatetc, ADVF advf, IAdviseSink adviseSink, out int connection)
{
// Check that the specified advisory flags are supported.
const ADVF c_advfAllowed = ADVF.ADVF_NODATA | ADVF.ADVF_ONLYONCE | ADVF.ADVF_PRIMEFIRST;
if ((int)((advf | c_advfAllowed) ^ c_advfAllowed) != 0)
{
connection = 0;
return OLE_E_ADVISENOTSUPPORTED;
}
// Create and insert an entry for the connection list
var entry = new AdviseEntry
{
Format = pFormatetc,
Advf = advf,
Sink = adviseSink,
};
m_connections.Add(m_nextConnectionId, entry);
connection = m_nextConnectionId;
m_nextConnectionId++;
// If the ADVF_PRIMEFIRST flag is specified and the data exists,
// raise the DataChanged event now.
if ((advf & ADVF.ADVF_PRIMEFIRST) == ADVF.ADVF_PRIMEFIRST)
{
OleData dataEntry;
if (GetDataEntry(ref pFormatetc, out dataEntry))
RaiseDataChanged(connection, ref dataEntry);
}
return 0;
}
protected override bool InternalGetDataHere(ref System.Runtime.InteropServices.ComTypes.FORMATETC format, ref System.Runtime.InteropServices.ComTypes.STGMEDIUM medium)
{
if (format.cfFormat == DataObjectHelper.CF_EMBEDSOURCE && (format.tymed & TYMED.TYMED_ISTORAGE) != 0)
{
medium.tymed = TYMED.TYMED_ISTORAGE;
medium.pUnkForRelease = null;
var stg = (IStorage)Marshal.GetObjectForIUnknown(medium.unionmember);
// we don't save the document directly, since this would mean to save the whole (and probably huge) project
// instead we first make a mini project with the neccessary data only and then save this instead
InternalSaveMiniProject(stg, _altaxoMiniProject, _graphDocumentName);
return(true);
}
if (format.cfFormat == DataObjectHelper.CF_LINKSOURCE && (format.tymed & TYMED.TYMED_ISTREAM) != 0)
{
// we should make sure that ComManager is already started, so that the moniker can be used by the program
if (!_comManager.IsActive)
{
_comManager.StartLocalServer();
}
IMoniker documentMoniker = CreateNewDocumentMoniker();
if (null != documentMoniker)
{
medium.tymed = TYMED.TYMED_ISTREAM;
medium.pUnkForRelease = null;
var strm = (IStream)Marshal.GetObjectForIUnknown(medium.unionmember);
DataObjectHelper.SaveMonikerToStream(documentMoniker, strm);
return(true);
}
}
return(false);
}
private static void SetBoolFormat(this IDataObject dataObject, string format, bool val)
{
DataFormats.Format dataFormat = DataFormats.GetFormat(format);
ComTypes.FORMATETC formatETC = new ComTypes.FORMATETC();
formatETC.cfFormat = (short)dataFormat.Id;
formatETC.dwAspect = ComTypes.DVASPECT.DVASPECT_CONTENT;
formatETC.lindex = -1;
formatETC.ptd = IntPtr.Zero;
formatETC.tymed = ComTypes.TYMED.TYMED_HGLOBAL;
IntPtr num = Marshal.AllocHGlobal(4);
try
{
Marshal.Copy(BitConverter.GetBytes(val ? 1 : 0), 0, num, 4);
ComTypes.STGMEDIUM medium;
medium.pUnkForRelease = (object)null;
medium.tymed = ComTypes.TYMED.TYMED_HGLOBAL;
medium.unionmember = num;
((System.Runtime.InteropServices.ComTypes.IDataObject)dataObject).SetData(ref formatETC, ref medium, true);
}
catch
{
Marshal.FreeHGlobal(num);
throw;
}
}
/// <summary>
/// Adds an advisory connection for the specified format.
/// </summary>
/// <param name="pFormatetc">The format for which this sink is called for changes.</param>
/// <param name="advf">Advisory flags to specify callback behavior.</param>
/// <param name="adviseSink">The IAdviseSink to call for this connection.</param>
/// <param name="connection">Returns the new connection's ID.</param>
/// <returns>An HRESULT.</returns>
public int DAdvise(ref FORMATETC pFormatetc, ADVF advf, IAdviseSink adviseSink, out int connection) {
// Check that the specified advisory flags are supported.
const ADVF ADVF_ALLOWED = ADVF.ADVF_NODATA | ADVF.ADVF_ONLYONCE | ADVF.ADVF_PRIMEFIRST;
if ((int) ((advf | ADVF_ALLOWED) ^ ADVF_ALLOWED) != 0) {
connection = 0;
return OLE_E_ADVISENOTSUPPORTED;
}
// Create and insert an entry for the connection list
var entry = new AdviseEntry(ref pFormatetc, advf, adviseSink);
connections.Add(nextConnectionId, entry);
connection = nextConnectionId;
nextConnectionId++;
// If the ADVF_PRIMEFIRST flag is specified and the data exists,
// raise the DataChanged event now.
if ((advf & ADVF.ADVF_PRIMEFIRST) == ADVF.ADVF_PRIMEFIRST) {
KeyValuePair<FORMATETC, STGMEDIUM> dataEntry;
if (GetDataEntry(ref pFormatetc, out dataEntry))
RaiseDataChanged(connection, ref dataEntry);
}
// S_OK
return 0;
}
/// <summary>
/// Handles DataChanged events from a COM IDataObject.
/// </summary>
/// <param name="format">The data format that had a change.</param>
/// <param name="stgmedium">The data value.</param>
public void OnDataChange(ref ComTypes.FORMATETC format, ref ComTypes.STGMEDIUM stgmedium)
{
// We listen to DropDescription changes, so that we can unset the IsDefault
// drop description flag.
object odd = ComTypes.ComDataObjectExtensions.GetDropDescription((ComTypes.IDataObject)data);
//if (odd != null)
//DragSourceHelper.SetDropDescriptionIsDefault(data, false);
}
/// <summary>
/// Sets managed data to a clipboard DataObject.
/// </summary>
/// <param name="dataObject">The DataObject to set the data on.</param>
/// <param name="format">The clipboard format.</param>
/// <param name="data">The data object.</param>
/// <remarks>
/// Because the underlying data store is not storing managed objects, but
/// unmanaged ones, this function provides intelligent conversion, allowing
/// you to set unmanaged data into the COM implemented IDataObject.</remarks>
public static void SetDataEx(this IDataObject dataObject, string format, object data)
{
DataFormats.Format dataFormat = DataFormats.GetFormat(format);
// Initialize the format structure
ComTypes.FORMATETC formatETC = new ComTypes.FORMATETC();
formatETC.cfFormat = (short)dataFormat.Id;
formatETC.dwAspect = ComTypes.DVASPECT.DVASPECT_CONTENT;
formatETC.lindex = -1;
formatETC.ptd = IntPtr.Zero;
// Try to discover the TYMED from the format and data
ComTypes.TYMED tymed = GetCompatibleTymed(format, data);
// If a TYMED was found, we can use the system DataObject
// to convert our value for us.
if (tymed != ComTypes.TYMED.TYMED_NULL)
{
formatETC.tymed = tymed;
if (data is byte[] bytes)
{
// don't convert byte array as it adds extra data
ComTypes.ComDataObjectExtensions.SetByteData((ComTypes.IDataObject)dataObject, format, bytes);
}
else
{
// Set data on an empty DataObject instance
DataObject conv = new DataObject();
conv.SetData(format, true, data);
// Now retrieve the data, using the COM interface.
// This will perform a managed to unmanaged conversion for us.
ComTypes.STGMEDIUM medium;
((ComTypes.IDataObject)conv).GetData(ref formatETC, out medium);
try
{
// Now set the data on our data object
((ComTypes.IDataObject)dataObject).SetData(ref formatETC, ref medium, true);
}
catch
{
// On exceptions, release the medium
ReleaseStgMedium(ref medium);
throw;
}
}
}
else
{
// Since we couldn't determine a TYMED, this data
// is likely custom managed data, and won't be used
// by unmanaged code, so we'll use our custom marshaling
// implemented by our COM IDataObject extensions.
ComTypes.ComDataObjectExtensions.SetManagedData((ComTypes.IDataObject)dataObject, format, data);
}
}
///////////////////////////////////////////////////////////////////////////////////
// FORMATETC
static internal OleInterop.FORMATETC BclFormatETC2Ole(ref BclComTypes.FORMATETC bclFormat)
{
OleInterop.FORMATETC oleFormat;
oleFormat.cfFormat = (ushort)bclFormat.cfFormat;
oleFormat.dwAspect = (uint)bclFormat.dwAspect;
oleFormat.lindex = bclFormat.lindex;
oleFormat.ptd = bclFormat.ptd;
oleFormat.tymed = (uint)bclFormat.tymed;
return(oleFormat);
}
/// <summary>
/// Extracts data of type <c>Dataformat.Html</c> from an <c>IDataObject</c> data container
/// This method shouldn't throw any exception but writes relevant exception informations in the debug window
/// </summary>
/// <param name="data">data container</param>
/// <returns>A byte[] array with the decoded string or null if the method fails</returns>
/// <remarks>Added 2006-06-12, <c>Uwe Keim</c>.</remarks>
private static byte[] getHtml(
IDataObject data)
{
var interopData = (System.Runtime.InteropServices.ComTypes.IDataObject)data;
var format =
new FORMATETC
{
cfFormat = ((short)DataFormats.GetFormat(DataFormats.Html).Id),
dwAspect = DVASPECT.DVASPECT_CONTENT,
lindex = (-1),
tymed = TYMED.TYMED_HGLOBAL
};
STGMEDIUM stgmedium;
stgmedium.tymed = TYMED.TYMED_HGLOBAL;
stgmedium.pUnkForRelease = null;
var queryResult = interopData.QueryGetData(ref format);
if (queryResult != 0)
{
return null;
}
interopData.GetData(ref format, out stgmedium);
if (stgmedium.unionmember == IntPtr.Zero)
{
return null;
}
var pointer = stgmedium.unionmember;
var handleRef = new HandleRef(null, pointer);
byte[] rawArray;
try
{
var ptr1 = GlobalLock(handleRef);
var length = GlobalSize(handleRef);
rawArray = new byte[length];
Marshal.Copy(ptr1, rawArray, 0, length);
}
finally
{
GlobalUnlock(handleRef);
}
return rawArray;
}
int BclComTypes.IDataObject.QueryGetData(ref BclComTypes.FORMATETC format)
{
if (null != bclData)
{
return(bclData.QueryGetData(ref format));
}
OleInterop.FORMATETC[] oleFormat = new OleInterop.FORMATETC[1];
oleFormat[0] = StructConverter.BclFormatETC2Ole(ref format);
return(oleData.QueryGetData(oleFormat));
}
public int GetCanonicalFormatEtc(ref FORMATETC formatIn, out FORMATETC formatOut)
{
switch (formatIn.cfFormat)
{
case CF.TEXT:
case CF.UNICODETEXT:
return(PlainTextDataObject.GetCanonicalFormatEtc(ref formatIn, out formatOut));
default:
return(DataObject.GetCanonicalFormatEtc(ref formatIn, out formatOut));
}
}
public int QueryGetData(ref FORMATETC format)
{
switch (format.cfFormat)
{
case CF.TEXT:
case CF.UNICODETEXT:
return(PlainTextDataObject.QueryGetData(ref format));
default:
return(DataObject.QueryGetData(ref format));
}
}
/// <summary>
/// Gets the file list.
/// </summary>
/// <param name="this">The IDataObject instance.</param>
/// <returns>The file list in the data object.</returns>
public static List<string> GetFileList(this IDataObject @this)
{
// Create the format object.
var formatEtc = new FORMATETC();
// Set up the format object, based on CF_HDROP.
formatEtc.cfFormat = (short)CLIPFORMAT.CF_HDROP;
formatEtc.ptd = IntPtr.Zero;
formatEtc.dwAspect = DVASPECT.DVASPECT_CONTENT;
formatEtc.lindex = -1;
formatEtc.tymed = TYMED.TYMED_HGLOBAL;
// Get the data.
// ReSharper disable RedundantAssignment
var storageMedium = new STGMEDIUM();
// ReSharper restore RedundantAssignment
@this.GetData(ref formatEtc, out storageMedium);
var fileList = new List<string>();
// Things can get risky now.
try
{
// Get the handle to the HDROP.
var hDrop = storageMedium.unionmember;
if (hDrop == IntPtr.Zero)
throw new ArgumentException("Failed to get the handle to the drop data.");
// Get the count of the files in the operation.
var fileCount = Shell32.DragQueryFile(hDrop, UInt32.MaxValue, null, 0);
// Go through each file.
for (uint i = 0; i < fileCount; i++)
{
// Storage for the file name.
var fileNameBuilder = new StringBuilder(MaxPath);
// Get the file name.
var result = Shell32.DragQueryFile(hDrop, i, fileNameBuilder, (uint)fileNameBuilder.Capacity);
// If we have a valid result, add the file name to the list of files.
if (result != 0)
fileList.Add(fileNameBuilder.ToString());
}
}
finally
{
Ole32.ReleaseStgMedium(ref storageMedium);
}
return fileList;
}
public void SetData(ref FORMATETC formatIn, ref STGMEDIUM medium, bool release)
{
switch (formatIn.cfFormat)
{
case CF.TEXT:
case CF.UNICODETEXT:
PlainTextDataObject.SetData(ref formatIn, ref medium, release);
break;
default:
DataObject.SetData(ref formatIn, ref medium, release);
break;
}
}
protected override bool InternalGetDataHere(ref System.Runtime.InteropServices.ComTypes.FORMATETC format, ref System.Runtime.InteropServices.ComTypes.STGMEDIUM medium)
{
if (format.cfFormat == DataObjectHelper.CF_EMBEDSOURCE && (format.tymed & TYMED.TYMED_ISTORAGE) != 0)
{
medium.tymed = TYMED.TYMED_ISTORAGE;
medium.pUnkForRelease = null;
var stg = (IStorage)Marshal.GetObjectForIUnknown(medium.unionmember);
Save(stg, false);
return(true);
}
return(false);
}
void BclComTypes.IDataObject.SetData(ref BclComTypes.FORMATETC formatIn, ref BclComTypes.STGMEDIUM medium, bool release)
{
if (null != bclData)
{
bclData.SetData(ref formatIn, ref medium, release);
return;
}
OleInterop.FORMATETC[] oleFormat = new OleInterop.FORMATETC[1];
oleFormat[0] = StructConverter.BclFormatETC2Ole(ref formatIn);
OleInterop.STGMEDIUM[] oleMedium = new OleInterop.STGMEDIUM[1];
oleMedium[0] = StructConverter.BclSTGMEDIUM2Ole(ref medium);
oleData.SetData(oleFormat, oleMedium, release ? 1 : 0);
}
void BclComTypes.IDataObject.GetData(ref BclComTypes.FORMATETC format, out BclComTypes.STGMEDIUM medium)
{
if (null != bclData)
{
bclData.GetData(ref format, out medium);
return;
}
OleInterop.FORMATETC[] oleFormat = new OleInterop.FORMATETC[1];
oleFormat[0] = StructConverter.BclFormatETC2Ole(ref format);
OleInterop.STGMEDIUM[] oleMedium = new OleInterop.STGMEDIUM[1];
oleData.GetData(oleFormat, oleMedium);
medium = StructConverter.OleSTGMEDIUM2Bcl(ref oleMedium[0]);
}
public void GetDataHere(ref FORMATETC format, ref STGMEDIUM medium)
{
switch (format.cfFormat)
{
case CF.TEXT:
case CF.UNICODETEXT:
PlainTextDataObject.GetDataHere(ref format, ref medium);
break;
default:
DataObject.GetDataHere(ref format, ref medium);
break;
}
}
void System.Runtime.InteropServices.ComTypes.IDataObject.GetData(ref FORMATETC formatetc, out STGMEDIUM medium)
{
if (formatetc.cfFormat == (Int16)DataFormats.GetFormat(NativeMethods.CFSTR_FILECONTENTS).Id)
m_lindex = formatetc.lindex;
medium = new System.Runtime.InteropServices.ComTypes.STGMEDIUM();
if (GetTymedUseable(formatetc.tymed)) {
if (formatetc.cfFormat == (Int16)DataFormats.GetFormat(NativeMethods.CFSTR_FILECONTENTS).Id) {
if ((formatetc.tymed & TYMED.TYMED_ISTREAM) != TYMED.TYMED_NULL) {
medium.tymed = TYMED.TYMED_ISTREAM;
// medium.unionmember = Marshal.GetComInterfaceForObject(GetFileContents(this.m_SelectedItems, formatetc.lindex), typeof(IStreamWrapper));
medium.unionmember = NativeMethods.VirtualAlloc(IntPtr.Zero, new UIntPtr(1), NativeMethods.MEM_COMMIT, NativeMethods.PAGE_READWRITE);
if (medium.unionmember == IntPtr.Zero) {
throw new OutOfMemoryException();
}
try {
((System.Runtime.InteropServices.ComTypes.IDataObject)this).GetDataHere(ref formatetc, ref medium);
return;
} catch {
NativeMethods.VirtualFree(medium.unionmember, new UIntPtr(1), NativeMethods.MEM_DECOMMIT);
medium.unionmember = IntPtr.Zero;
throw;
}
}
} else {
if ((formatetc.tymed & TYMED.TYMED_HGLOBAL) != TYMED.TYMED_NULL) {
medium.tymed = TYMED.TYMED_HGLOBAL;
medium.unionmember = NativeMethods.GlobalAlloc(NativeMethods.GHND | NativeMethods.GMEM_DDESHARE, 1);
if (medium.unionmember == IntPtr.Zero) {
throw new OutOfMemoryException();
}
try {
((System.Runtime.InteropServices.ComTypes.IDataObject)this).GetDataHere(ref formatetc, ref medium);
return;
} catch {
NativeMethods.GlobalFree(new HandleRef((STGMEDIUM)medium, medium.unionmember));
medium.unionmember = IntPtr.Zero;
throw;
}
}
}
medium.tymed = formatetc.tymed;
((System.Runtime.InteropServices.ComTypes.IDataObject)this).GetDataHere(ref formatetc, ref medium);
} else {
Marshal.ThrowExceptionForHR(NativeMethods.DV_E_TYMED);
}
}
int OleInterop.IDataObject.QueryGetData(OleInterop.FORMATETC[] pFormatetc)
{
if (null != oleData)
{
return(oleData.QueryGetData(pFormatetc));
}
if ((null == pFormatetc) || (1 != pFormatetc.Length))
{
throw new ArgumentException();
}
BclComTypes.FORMATETC bclFormat = StructConverter.OleFormatETC2Bcl(ref pFormatetc[0]);
return(bclData.QueryGetData(ref bclFormat));
}
int BclComTypes.IDataObject.GetCanonicalFormatEtc(ref BclComTypes.FORMATETC formatIn, out BclComTypes.FORMATETC formatOut)
{
if (null != bclData)
{
return(bclData.GetCanonicalFormatEtc(ref formatIn, out formatOut));
}
OleInterop.FORMATETC[] oleFormatIn = new OleInterop.FORMATETC[1];
OleInterop.FORMATETC[] oleFormatOut = new OleInterop.FORMATETC[1];
oleFormatIn[0] = StructConverter.BclFormatETC2Ole(ref formatIn);
int hr = oleData.GetCanonicalFormatEtc(oleFormatIn, oleFormatOut);
NativeMethods.ThrowOnFailure(hr);
formatOut = StructConverter.OleFormatETC2Bcl(ref oleFormatOut[0]);
return(hr);
}
protected override bool InternalGetDataHere(ref System.Runtime.InteropServices.ComTypes.FORMATETC format, ref System.Runtime.InteropServices.ComTypes.STGMEDIUM medium)
{
if (format.cfFormat == DataObjectHelper.CF_LINKSOURCE && (format.tymed & TYMED.TYMED_ISTREAM) != 0)
{
var moniker = Moniker;
if (null != moniker)
{
medium.tymed = TYMED.TYMED_ISTREAM;
medium.pUnkForRelease = null;
var strm = (IStream)Marshal.GetObjectForIUnknown(medium.unionmember);
DataObjectHelper.SaveMonikerToStream(Moniker, strm);
return(true);
}
}
return(false);
}
public void Initialize(IntPtr pidlFolder, IntPtr pDataObj, IntPtr hKeyProgID)
{
if (pDataObj == IntPtr.Zero)
{
throw new ArgumentException();
}
FORMATETC fe = new FORMATETC();
fe.cfFormat = (short)CLIPFORMAT.HDROP;
fe.ptd = IntPtr.Zero;
fe.dwAspect = DVASPECT.DVASPECT_CONTENT;
fe.lindex = -1;
fe.tymed = TYMED.TYMED_HGLOBAL;
STGMEDIUM stm = new STGMEDIUM();
// The pDataObj pointer contains the objects being acted upon. In this
// example, we get an HDROP handle for enumerating the selected files
// and folders.
IDataObject dataObject = (IDataObject)Marshal.GetObjectForIUnknown(pDataObj);
dataObject.GetData(ref fe, out stm);
try
{
// Get an HDROP handle.
IntPtr hDrop = stm.unionmember;
if (hDrop == IntPtr.Zero)
{
throw new ArgumentException();
}
uint nFiles = Import.DragQueryFile(hDrop, UInt32.MaxValue, null, 0);
if (nFiles == 0)
{
Marshal.ThrowExceptionForHR(ErrorCode.E_FAIL);
}
selectedFiles = new List<string>();
for (uint i = 0; i < nFiles; i++)
{
selectedFiles.Add(getFileName(hDrop, i));
}
}
finally
{
Import.ReleaseStgMedium(ref stm);
}
}
ShellItem[] ParseShellIDListArray(ComTypes.IDataObject pDataObj)
{
List <ShellItem> result = new List <ShellItem>();
ComTypes.FORMATETC format = new ComTypes.FORMATETC();
ComTypes.STGMEDIUM medium = new ComTypes.STGMEDIUM();
format.cfFormat = (short)User32.RegisterClipboardFormat("Shell IDList Array");
format.dwAspect = ComTypes.DVASPECT.DVASPECT_CONTENT;
format.lindex = 0;
format.ptd = IntPtr.Zero;
format.tymed = ComTypes.TYMED.TYMED_HGLOBAL;
pDataObj.GetData(ref format, out medium);
Kernel32.GlobalLock(medium.unionmember);
try
{
ShellItem parentFolder = null;
int count = Marshal.ReadInt32(medium.unionmember);
int offset = 4;
for (int n = 0; n <= count; ++n)
{
int pidlOffset = Marshal.ReadInt32(medium.unionmember, offset);
int pidlAddress = (int)medium.unionmember + pidlOffset;
if (n == 0)
{
parentFolder = new ShellItem(new IntPtr(pidlAddress));
}
else
{
result.Add(new ShellItem(parentFolder, new IntPtr(pidlAddress)));
}
offset += 4;
}
}
finally
{
Marshal.FreeHGlobal(medium.unionmember);
}
return(result.ToArray());
}
public void GetDataHere(ref System.Runtime.InteropServices.ComTypes.FORMATETC format, ref System.Runtime.InteropServices.ComTypes.STGMEDIUM medium)
{
ComDebug.ReportInfo("{0}.IDataObject.GetDataHere({1})", GetType().Name, DataObjectHelper.ClipboardFormatName(format.cfFormat));
// Allows containers to duplicate this into their own storage.
try
{
if (InternalGetDataHere(ref format, ref medium))
{
return; // data could be provided
}
}
catch (Exception e)
{
ComDebug.ReportError("{0}.IDataObject.GetDataHere threw an exception: {1}", GetType().Name, e);
throw;
}
Marshal.ThrowExceptionForHR(ComReturnValue.DATA_E_FORMATETC);
}
void OleInterop.IDataObject.SetData(OleInterop.FORMATETC[] pFormatetc, OleInterop.STGMEDIUM[] pmedium, int fRelease)
{
if (null != oleData)
{
oleData.SetData(pFormatetc, pmedium, fRelease);
return;
}
if ((null == pFormatetc) || (1 != pFormatetc.Length) ||
(null == pmedium) || (1 != pmedium.Length))
{
throw new ArgumentException();
}
BclComTypes.FORMATETC bclFormat = StructConverter.OleFormatETC2Bcl(ref pFormatetc[0]);
BclComTypes.STGMEDIUM bclMedium = StructConverter.OleSTGMEDIUM2Bcl(ref pmedium[0]);
bclData.SetData(ref bclFormat, ref bclMedium, (fRelease == 0) ? false : true);
}
public int DAdvise(ref FORMATETC formatetc, ADVF advf, IAdviseSink adviseSink, out int connection)
{
if (((advf | ADVF.ADVF_NODATA | ADVF.ADVF_PRIMEFIRST | ADVF.ADVF_ONLYONCE) ^ (ADVF.ADVF_NODATA | ADVF.ADVF_PRIMEFIRST | ADVF.ADVF_ONLYONCE)) != (ADVF)0)
{
connection = 0;
return -2147221501;
}
else
{
this.connections.Add(this.nextConnectionId, new AdviseEntry(ref formatetc, advf, adviseSink));
connection = this.nextConnectionId;
++this.nextConnectionId;
KeyValuePair<FORMATETC, STGMEDIUM> dataEntry;
if ((advf & ADVF.ADVF_PRIMEFIRST) == ADVF.ADVF_PRIMEFIRST && this.GetDataEntry(ref formatetc, out dataEntry))
this.RaiseDataChanged(connection, ref dataEntry);
return 0;
}
}
internal static bool IsFormatValid(FORMATETC[] formats) {
Debug.Assert(formats != null, "Null returned from GetFormats");
if (formats != null) {
if (formats.Length <= 4) {
for (int i = 0; i < formats.Length; i++) {
short format = formats[i].cfFormat;
if (format != NativeMethods.CF_TEXT &&
format != NativeMethods.CF_UNICODETEXT &&
format != DataFormats.GetFormat("System.String").Id &&
format != DataFormats.GetFormat("Csv").Id) {
return false;
}
}
return true;
}
}
return false;
}
void IBclAdviseSink.OnDataChange(ref BclComTypes.FORMATETC format, ref BclComTypes.STGMEDIUM stgmedium)
{
if (null != bclSink)
{
bclSink.OnDataChange(ref format, ref stgmedium);
}
else
{
// As in the previous case we have to copy the parameters.
OleInterop.FORMATETC[] pFormatetc = new OleInterop.FORMATETC[1];
pFormatetc[0] = StructConverter.BclFormatETC2Ole(ref format);
OleInterop.STGMEDIUM[] pStgmed = new OleInterop.STGMEDIUM[1];
pStgmed[0] = StructConverter.BclSTGMEDIUM2Ole(ref stgmedium);
// Call the original interface.
oleSink.OnDataChange(pFormatetc, pStgmed);
}
}
void OleInterop.IDataObject.GetDataHere(OleInterop.FORMATETC[] pFormatetc, OleInterop.STGMEDIUM[] pRemoteMedium)
{
if (null != oleData)
{
oleData.GetDataHere(pFormatetc, pRemoteMedium);
return;
}
// Check that the arrays are not null and with only one element.
if ((null == pFormatetc) || (pFormatetc.Length != 1) ||
(null == pRemoteMedium) || (pRemoteMedium.Length != 1))
{
throw new ArgumentException();
}
// Call the method on the BCL interface
BclComTypes.FORMATETC bclFormat = StructConverter.OleFormatETC2Bcl(ref pFormatetc[0]);
BclComTypes.STGMEDIUM bclMedium = StructConverter.OleSTGMEDIUM2Bcl(ref pRemoteMedium[0]);
bclData.GetDataHere(ref bclFormat, ref bclMedium);
pRemoteMedium[0] = StructConverter.BclSTGMEDIUM2Ole(ref bclMedium);
}
public static List <byte[][]> GetPidls(System.Runtime.InteropServices.ComTypes.IDataObject pDataObj)
{
List <byte[][]> lsRet = new List <byte[][]>();
try
{
STGMEDIUM medium;
System.Runtime.InteropServices.ComTypes.FORMATETC formatShell = new System.Runtime.InteropServices.ComTypes.FORMATETC()
{
cfFormat = (Int16)DataFormats.GetFormat(NativeMethods.CFSTR_SHELLIDLIST).Id,
dwAspect = DVASPECT.DVASPECT_CONTENT,
tymed = TYMED.TYMED_HGLOBAL
};
System.Runtime.InteropServices.ComTypes.FORMATETC format = new System.Runtime.InteropServices.ComTypes.FORMATETC()
{
cfFormat = (Int16)DataFormats.GetFormat(NativeMethods.CF_HDROP).Id,
dwAspect = DVASPECT.DVASPECT_CONTENT,
tymed = TYMED.TYMED_HGLOBAL
};
int ret = pDataObj.QueryGetData(ref format);
if (ret > 0)
{
pDataObj.GetData(ref formatShell, out medium);
IntPtr ptr;
ptr = medium.unionmember;
IntPtr ptrLock = NativeMethods.GlobalLock(ptr);
lsRet = ProcessCIDA_Pidl(ptr);
NativeMethods.GlobalUnlock(ptrLock);
}
}
catch (Exception)
{
}
return(lsRet);
}
public void Drop(IDataObject dataObject, uint keyState, Point pt, ref uint effect)
{
FORMATETC format = new FORMATETC()
{
cfFormat = NativeMethods.CF_HDROP,
dwAspect = DVASPECT.DVASPECT_CONTENT,
tymed = TYMED.TYMED_HGLOBAL
};
STGMEDIUM medium;
string[] files;
dataObject.GetData(ref format, out medium);
try
{
IntPtr dropHandle = medium.unionmember;
int fileCount = NativeMethods.DragQueryFile(new HandleRef(this, dropHandle), -1, null, 0);
files = new string[fileCount];
for (int x = 0; x < fileCount; ++x)
{
int size = NativeMethods.DragQueryFile(new HandleRef(this, dropHandle), x, null, 0);
if (size > 0)
{
StringBuilder fileName = new StringBuilder(size + 1);
if (NativeMethods.DragQueryFile(new HandleRef(this, dropHandle), x, fileName, fileName.Capacity) > 0)
files[x] = fileName.ToString();
}
}
}
finally
{
NativeMethods.ReleaseStgMedium(ref medium);
}
foreach (string file in files)
{
Client.OpenGLContextThread.Add(() =>
{
ImportExportUtil.Import(file);
});
}
}
int OleInterop.IDataObject.GetCanonicalFormatEtc(OleInterop.FORMATETC[] pformatectIn, OleInterop.FORMATETC[] pformatetcOut)
{
if (null != oleData)
{
return(oleData.GetCanonicalFormatEtc(pformatectIn, pformatetcOut));
}
// Check that the arrays are not null and with only one element.
if ((null == pformatectIn) || (pformatectIn.Length != 1) ||
(null == pformatetcOut) || (pformatetcOut.Length != 1))
{
throw new ArgumentException();
}
BclComTypes.FORMATETC bclFormatIn = StructConverter.OleFormatETC2Bcl(ref pformatectIn[0]);
BclComTypes.FORMATETC bclFormatOut;
int hr = bclData.GetCanonicalFormatEtc(ref bclFormatIn, out bclFormatOut);
NativeMethods.ThrowOnFailure(hr);
pformatetcOut[0] = StructConverter.BclFormatETC2Ole(ref bclFormatOut);
return(hr);
}
int BclComTypes.IDataObject.DAdvise(ref BclComTypes.FORMATETC pFormatetc, BclComTypes.ADVF advf, BclComTypes.IAdviseSink adviseSink, out int connection)
{
if (null != bclData)
{
return(bclData.DAdvise(ref pFormatetc, advf, adviseSink, out connection));
}
OleInterop.FORMATETC[] oleFormat = new OleInterop.FORMATETC[1];
oleFormat[0] = StructConverter.BclFormatETC2Ole(ref pFormatetc);
uint result;
OleInterop.IAdviseSink oleSink = adviseSink as OleInterop.IAdviseSink;
if (null == oleSink)
{
oleSink = (OleInterop.IAdviseSink)(new AdviseSink(adviseSink));
}
int hr = oleData.DAdvise(oleFormat, (uint)advf, oleSink, out result);
NativeMethods.ThrowOnFailure(hr);
connection = (int)result;
return(hr);
}
//[SecurityPermission(SecurityAction.Demand, Flags = SecurityPermissionFlag.UnmanagedCode)]
void System.Runtime.InteropServices.ComTypes.IDataObject.GetData(ref System.Runtime.InteropServices.ComTypes.FORMATETC formatetc, out System.Runtime.InteropServices.ComTypes.STGMEDIUM medium)
{
if (formatetc.cfFormat == (Int16)DataFormats.GetFormat(NativeMethods.CFSTR_FILECONTENTS).Id)
{
m_lindex = formatetc.lindex;
}
medium = new System.Runtime.InteropServices.ComTypes.STGMEDIUM();
if (GetTymedUseable(formatetc.tymed))
{
if ((formatetc.tymed & TYMED.TYMED_HGLOBAL) != TYMED.TYMED_NULL)
{
medium.tymed = TYMED.TYMED_HGLOBAL;
medium.unionmember = NativeMethods.GlobalAlloc(NativeMethods.GHND | NativeMethods.GMEM_DDESHARE, 1);
if (medium.unionmember == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
try
{
((System.Runtime.InteropServices.ComTypes.IDataObject) this).GetDataHere(ref formatetc, ref medium);
return;
}
catch
{
NativeMethods.GlobalFree(new HandleRef((STGMEDIUM)medium, medium.unionmember));
medium.unionmember = IntPtr.Zero;
throw;
}
}
medium.tymed = formatetc.tymed;
((System.Runtime.InteropServices.ComTypes.IDataObject) this).GetDataHere(ref formatetc, ref medium);
}
else
{
Marshal.ThrowExceptionForHR(NativeMethods.DV_E_TYMED);
}
}
public static void SetDataEx(this System.Windows.IDataObject dataObject, string format, object data)
{
DataFormat dataFormat = DataFormats.GetDataFormat(format);
FORMATETC formatetc = new FORMATETC()
{
cfFormat = (short)dataFormat.Id,
dwAspect = DVASPECT.DVASPECT_CONTENT,
lindex = -1,
ptd = IntPtr.Zero
};
TYMED compatibleTymed = DataObjectExtensions.GetCompatibleTymed(format, data);
if (compatibleTymed != TYMED.TYMED_NULL)
{
formatetc.tymed = compatibleTymed;
System.Windows.IDataObject dataObject1 = new System.Windows.DataObject();
dataObject1.SetData(format, data, true);
STGMEDIUM medium;
((System.Runtime.InteropServices.ComTypes.IDataObject)dataObject1).GetData(ref formatetc, out medium);
try
{
((System.Runtime.InteropServices.ComTypes.IDataObject)dataObject).SetData(ref formatetc, ref medium, true);
}
catch
{
Advent.Common.Interop.NativeMethods.ReleaseStgMedium(ref medium);
throw;
}
}
else
DataObjectExtensions.SetManagedData(dataObject, format, data);
}
public static void SetVirtualFiles(this Advent.Common.Interop.DataObject dataObject, VirtualFile[] files)
{
MemoryStream memoryStream = new MemoryStream();
memoryStream.Write(BitConverter.GetBytes(files.Length), 0, 4);
for (int index = 0; index < files.Length; ++index)
{
VirtualFile file = files[index];
if (file.ContentsFunc == null)
{
FORMATETC formatIn = new FORMATETC()
{
cfFormat = (short)DataFormats.GetDataFormat("FileContents").Id,
dwAspect = DVASPECT.DVASPECT_CONTENT,
lindex = index,
ptd = IntPtr.Zero,
tymed = TYMED.TYMED_ISTREAM
};
STGMEDIUM medium = DataObjectExtensions.WriteBytesToMedium(file.Contents);
dataObject.SetData(ref formatIn, ref medium, true);
}
DataObjectExtensions.WriteFileDescriptor((Stream)memoryStream, file);
}
dataObject.DataRequested += (EventHandler<DataRequestedEventArgs>)((sender, args) =>
{
int local_0 = (int)(short)DataFormats.GetDataFormat("FileContents").Id;
if ((int)args.Format.cfFormat != local_0 || args.Format.lindex < 0 || (args.Format.lindex >= files.Length || files[args.Format.lindex].ContentsFunc == null))
return;
args.Medium = DataObjectExtensions.WriteBytesToMedium(files[args.Format.lindex].ContentsFunc());
args.IsHandled = true;
});
IntPtr num = Marshal.AllocHGlobal((int)memoryStream.Length);
try
{
Marshal.Copy(memoryStream.GetBuffer(), 0, num, (int)memoryStream.Length);
}
catch
{
Marshal.FreeHGlobal(num);
throw;
}
STGMEDIUM medium1;
medium1.pUnkForRelease = (object)null;
medium1.tymed = TYMED.TYMED_HGLOBAL;
medium1.unionmember = num;
FORMATETC formatIn1 = new FORMATETC()
{
cfFormat = (short)DataFormats.GetDataFormat("FileGroupDescriptorW").Id,
dwAspect = DVASPECT.DVASPECT_CONTENT,
lindex = -1,
ptd = IntPtr.Zero,
tymed = TYMED.TYMED_HGLOBAL
};
dataObject.SetData(ref formatIn1, ref medium1, true);
}
void IComDataObject.SetData(ref FORMATETC pFormatetcIn, ref STGMEDIUM pmedium, bool fRelease) {
Debug.WriteLineIf(CompModSwitches.DataObject.TraceVerbose, "SetData");
if (innerData is OleConverter) {
((OleConverter)innerData).OleDataObject.SetData(ref pFormatetcIn, ref pmedium, fRelease);
return;
}
//
throw new NotImplementedException();
}
public void OnDataChange(ref FORMATETC format, ref STGMEDIUM stgmedium)
{
if (DataObjectExtensions.GetDropDescription(this.data) == null)
return;
DataObjectExtensions.SetDropDescriptionIsDefault(this.data, false);
}
/// <summary> /// Internal implementation of the GetDataHere procedure. It is not neccessary to catch exceptions into this implementations, since the exceptions are catched and reported /// in the outer <see cref="GetDataHere"/> function. /// </summary> /// <param name="format">The format.</param> /// <param name="medium">The medium.</param> /// <returns><c>True</c> if the data could be provided, otherwise <c>False</c>.</returns> protected abstract bool InternalGetDataHere(ref System.Runtime.InteropServices.ComTypes.FORMATETC format, ref System.Runtime.InteropServices.ComTypes.STGMEDIUM medium);
/// <include file='doc\DataObject.uex' path='docs/doc[@for="DataObject.OleConverter.GetDataFromOleOther"]/*' />
/// <devdoc>
/// Retrieves the specified format data from the bound IComDataObject, from
/// other sources that IStream and HGLOBAL... this is really just a place
/// to put the "special" formats like BITMAP, ENHMF, etc.
/// </devdoc>
/// <internalonly/>
private Object GetDataFromOleOther(string format) {
Debug.Assert(innerData != null, "You must have an innerData on all DataObjects");
FORMATETC formatetc = new FORMATETC();
STGMEDIUM medium = new STGMEDIUM();
TYMED tymed = (TYMED)0;
if (format.Equals(DataFormats.Bitmap)) {
tymed = TYMED.TYMED_GDI;
}
else if (format.Equals(DataFormats.EnhancedMetafile)) {
tymed = TYMED.TYMED_ENHMF;
}
if (tymed == (TYMED)0) {
return null;
}
formatetc.cfFormat = unchecked((short)(ushort)(DataFormats.GetFormat(format).Id));
formatetc.dwAspect = DVASPECT.DVASPECT_CONTENT;
formatetc.lindex = -1;
formatetc.tymed = tymed;
medium.tymed = tymed;
Object data = null;
if (NativeMethods.S_OK == QueryGetDataUnsafe(ref formatetc)) {
try {
IntSecurity.UnmanagedCode.Assert();
try {
innerData.GetData(ref formatetc, out medium);
}
finally {
CodeAccessPermission.RevertAssert();
}
}
catch {
}
}
if (medium.unionmember != IntPtr.Zero) {
if (format.Equals(DataFormats.Bitmap)
//||format.Equals(DataFormats.Dib))
) {
// as/urt 140870 -- GDI+ doesn't own this HBITMAP, but we can't
// delete it while the object is still around. So we have to do the really expensive
// thing of cloning the image so we can release the HBITMAP.
//
//This bitmap is created by the com object which originally copied the bitmap to tbe
//clipboard. We call Add here, since DeleteObject calls Remove.
System.Internal.HandleCollector.Add(medium.unionmember, NativeMethods.CommonHandles.GDI);
Image clipboardImage = null;
IntSecurity.ObjectFromWin32Handle.Assert();
try
{
clipboardImage = Image.FromHbitmap(medium.unionmember);
}
finally
{
CodeAccessPermission.RevertAssert();
}
if (clipboardImage != null) {
Image firstImage = clipboardImage;
clipboardImage = (Image)clipboardImage.Clone();
SafeNativeMethods.DeleteObject(new HandleRef(null, medium.unionmember));
firstImage.Dispose();
}
data = clipboardImage;
}
/* gpr:
else if (format.Equals(DataFormats.EnhancedMetafile)) {
data = new Metafile(medium.unionmember);
}
*/
}
return data;
}
int IComDataObject.GetCanonicalFormatEtc(ref FORMATETC pformatetcIn, out FORMATETC pformatetcOut) {
Debug.WriteLineIf(CompModSwitches.DataObject.TraceVerbose, "GetCanonicalFormatEtc");
if (innerData is OleConverter) {
return ((OleConverter)innerData).OleDataObject.GetCanonicalFormatEtc(ref pformatetcIn, out pformatetcOut);
}
pformatetcOut = new FORMATETC();
return (DATA_S_SAMEFORMATETC);
}
/// <summary>
/// Handles DataChanged events from a COM IDataObject.
/// </summary>
/// <param name="format">The data format that had a change.</param>
/// <param name="stgmedium">The data value.</param>
public void OnDataChange(ref FORMATETC format, ref STGMEDIUM stgmedium)
{
// We listen to DropDescription changes, so that we can unset the IsDefault
// drop description flag.
var odd = DropDescriptionHelper.GetDropDescription(m_data);
if (odd != null)
{
DropDescriptionHelper.SetDropDescriptionIsDefault(m_data, false);
}
}
/// <include file='doc\DataObject.uex' path='docs/doc[@for="DataObject.GetDataIntoOleStructs"]/*' />
/// <devdoc>
/// Populates Ole datastructes from a [....] dataObject. This is the core
/// of [....] to OLE conversion.
/// </devdoc>
/// <internalonly/>
private void GetDataIntoOleStructs(ref FORMATETC formatetc,
ref STGMEDIUM medium) {
if (GetTymedUseable(formatetc.tymed) && GetTymedUseable(medium.tymed)) {
string format = DataFormats.GetFormat(formatetc.cfFormat).Name;
if (GetDataPresent(format)) {
Object data = GetData(format);
if ((formatetc.tymed & TYMED.TYMED_HGLOBAL) != 0) {
int hr = SaveDataToHandle(data, format, ref medium);
if (NativeMethods.Failed(hr)) {
Marshal.ThrowExceptionForHR(hr);
}
}
else if ((formatetc.tymed & TYMED.TYMED_GDI) != 0) {
if (format.Equals(DataFormats.Bitmap) && data is Bitmap) {
// save bitmap
//
Bitmap bm = (Bitmap)data;
if (bm != null) {
medium.unionmember = GetCompatibleBitmap(bm); // gpr: Does this get properly disposed?
}
}
}
/* gpr
else if ((formatetc.tymed & TYMED.TYMED_ENHMF) != 0) {
if (format.Equals(DataFormats.EnhancedMetafile)
&& data is Metafile) {
// save metafile
Metafile mf = (Metafile)data;
if (mf != null) {
medium.unionmember = mf.Handle;
}
}
}
*/
else {
Marshal.ThrowExceptionForHR (DV_E_TYMED);
}
}
else {
Marshal.ThrowExceptionForHR (DV_E_FORMATETC);
}
}
else {
Marshal.ThrowExceptionForHR (DV_E_TYMED);
}
}
int IComDataObject.DAdvise(ref FORMATETC pFormatetc, ADVF advf, IAdviseSink pAdvSink, out int pdwConnection) {
Debug.WriteLineIf(CompModSwitches.DataObject.TraceVerbose, "DAdvise");
if (innerData is OleConverter) {
return ((OleConverter)innerData).OleDataObject.DAdvise(ref pFormatetc, advf, pAdvSink, out pdwConnection);
}
pdwConnection = 0;
return (NativeMethods.E_NOTIMPL);
}
public virtual string[] GetFormats(bool autoConvert) {
Debug.Assert(innerData != null, "You must have an innerData on all DataObjects");
IEnumFORMATETC enumFORMATETC = null;
ArrayList formats = new ArrayList();
try {
enumFORMATETC = innerData.EnumFormatEtc(DATADIR.DATADIR_GET);
}
catch {
}
if (enumFORMATETC != null) {
enumFORMATETC.Reset();
FORMATETC[] formatetc = new FORMATETC[] { new FORMATETC()};
int[] retrieved = new int[] {1};
while (retrieved[0] > 0) {
retrieved[0] = 0;
try {
enumFORMATETC.Next(1, formatetc, retrieved);
}
catch {
}
if (retrieved[0] > 0) {
string name = DataFormats.GetFormat(formatetc[0].cfFormat).Name;
if (autoConvert) {
string[] mappedFormats = GetMappedFormats(name);
for (int i=0; i<mappedFormats.Length; i++) {
formats.Add(mappedFormats[i]);
}
}
else {
formats.Add(name);
}
}
}
}
string[] temp = new string[formats.Count];
formats.CopyTo(temp, 0);
return GetDistinctStrings(temp);
}
private bool GetDataPresentInner(string format) {
Debug.Assert(innerData != null, "You must have an innerData on all DataObjects");
FORMATETC formatetc = new FORMATETC();
formatetc.cfFormat = unchecked((short)(ushort)(DataFormats.GetFormat(format).Id));
formatetc.dwAspect = DVASPECT.DVASPECT_CONTENT;
formatetc.lindex = -1;
for (int i=0; i<ALLOWED_TYMEDS.Length; i++) {
formatetc.tymed |= ALLOWED_TYMEDS[i];
}
int hr = QueryGetDataUnsafe(ref formatetc);
return (hr == NativeMethods.S_OK);
}
private int QueryGetDataInner(ref FORMATETC formatetc)
{
return innerData.QueryGetData(ref formatetc);
}
public static void SetVirtualFiles(this System.Windows.IDataObject dataObject, VirtualFile[] files)
{
if (files == null)
throw new ArgumentNullException();
MemoryStream memoryStream = new MemoryStream();
memoryStream.Write(BitConverter.GetBytes(files.Length), 0, 4);
for (int index = 0; index < files.Length; ++index)
{
VirtualFile file = files[index];
if (file.Contents == null || file.Contents.Length == 0)
throw new ArgumentException("VirtualFile does not have any contents.");
FORMATETC formatIn = new FORMATETC()
{
cfFormat = (short)DataFormats.GetDataFormat("FileContents").Id,
dwAspect = DVASPECT.DVASPECT_CONTENT,
lindex = index,
ptd = IntPtr.Zero,
tymed = TYMED.TYMED_ISTREAM
};
STGMEDIUM medium = DataObjectExtensions.WriteBytesToMedium(file.Contents);
((System.Runtime.InteropServices.ComTypes.IDataObject)dataObject).SetData(ref formatIn, ref medium, true);
DataObjectExtensions.WriteFileDescriptor((Stream)memoryStream, file);
}
IntPtr num = Marshal.AllocHGlobal((int)memoryStream.Length);
try
{
Marshal.Copy(memoryStream.GetBuffer(), 0, num, (int)memoryStream.Length);
}
catch
{
Marshal.FreeHGlobal(num);
throw;
}
STGMEDIUM medium1;
medium1.pUnkForRelease = (object)null;
medium1.tymed = TYMED.TYMED_HGLOBAL;
medium1.unionmember = num;
FORMATETC formatIn1 = new FORMATETC()
{
cfFormat = (short)DataFormats.GetDataFormat("FileGroupDescriptorW").Id,
dwAspect = DVASPECT.DVASPECT_CONTENT,
lindex = -1,
ptd = IntPtr.Zero,
tymed = TYMED.TYMED_HGLOBAL
};
((System.Runtime.InteropServices.ComTypes.IDataObject)dataObject).SetData(ref formatIn1, ref medium1, true);
}
void IComDataObject.GetData(ref FORMATETC formatetc, out STGMEDIUM medium) {
Debug.WriteLineIf(CompModSwitches.DataObject.TraceVerbose, "GetData");
if (innerData is OleConverter) {
((OleConverter)innerData).OleDataObject.GetData(ref formatetc, out medium);
return;
}
medium = new STGMEDIUM();
if (GetTymedUseable(formatetc.tymed)) {
if ((formatetc.tymed & TYMED.TYMED_HGLOBAL) != 0) {
medium.tymed = TYMED.TYMED_HGLOBAL;
medium.unionmember = UnsafeNativeMethods.GlobalAlloc(NativeMethods.GMEM_MOVEABLE
| NativeMethods.GMEM_DDESHARE
| NativeMethods.GMEM_ZEROINIT,
1);
if (medium.unionmember == IntPtr.Zero) {
throw new OutOfMemoryException();
}
try {
((IComDataObject)this).GetDataHere(ref formatetc, ref medium);
}
catch {
UnsafeNativeMethods.GlobalFree(new HandleRef(medium, medium.unionmember));
medium.unionmember = IntPtr.Zero;
throw;
}
}
else {
medium.tymed = formatetc.tymed;
((IComDataObject)this).GetDataHere(ref formatetc, ref medium);
}
}
else {
Marshal.ThrowExceptionForHR(DV_E_TYMED);
}
}
private static void FillFormatETC(string format, TYMED tymed, out FORMATETC formatETC)
{
formatETC.cfFormat = (short)Advent.Common.Interop.NativeMethods.RegisterClipboardFormat(format);
formatETC.dwAspect = DVASPECT.DVASPECT_CONTENT;
formatETC.lindex = -1;
formatETC.ptd = IntPtr.Zero;
formatETC.tymed = tymed;
}
void IComDataObject.GetDataHere(ref FORMATETC formatetc, ref STGMEDIUM medium) {
Debug.WriteLineIf(CompModSwitches.DataObject.TraceVerbose, "GetDataHere");
if (innerData is OleConverter) {
((OleConverter)innerData).OleDataObject.GetDataHere(ref formatetc, ref medium);
}
else {
GetDataIntoOleStructs(ref formatetc, ref medium);
}
}
void System.Runtime.InteropServices.ComTypes.IDataObject.GetData(ref System.Runtime.InteropServices.ComTypes.FORMATETC formatetc, out System.Runtime.InteropServices.ComTypes.STGMEDIUM medium)
{
try
{
medium = new System.Runtime.InteropServices.ComTypes.STGMEDIUM();
if (formatetc.cfFormat == (Int16)DataFormats.GetFormat(NativeMethods.CFSTR_FILECONTENTS).Id)
{
m_lindex = formatetc.lindex;
}
if (GetTymedUseable(formatetc.tymed))
{
if ((formatetc.tymed & TYMED.TYMED_ISTREAM) != TYMED.TYMED_NULL)
{
if (objectType != ClipboardDataType.File)
{
return;
}
try
{
//DropSuccess?.Invoke(this, null);
medium.tymed = TYMED.TYMED_ISTREAM;
IStream o = (IStream)GetData("FileContents", false);
medium.unionmember = Marshal.GetComInterfaceForObject(o, typeof(IStream));
return;
}
catch (Exception ex)
{
//ISLogger.Write("InputshareDataObject: Get FileContents failed: " + ex.Message);
return;
}
}
else if ((formatetc.tymed & TYMED.TYMED_HGLOBAL) != TYMED.TYMED_NULL)
{
medium.tymed = TYMED.TYMED_HGLOBAL;
medium.unionmember = NativeMethods.GlobalAlloc(NativeMethods.GHND | NativeMethods.GMEM_DDESHARE, 1);
if (medium.unionmember == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
try
{
((System.Runtime.InteropServices.ComTypes.IDataObject) this).GetDataHere(ref formatetc, ref medium);
return;
}
catch
{
NativeMethods.GlobalFree(new HandleRef((STGMEDIUM)medium, medium.unionmember));
medium.unionmember = IntPtr.Zero;
return;
}
}
medium.tymed = formatetc.tymed;
((System.Runtime.InteropServices.ComTypes.IDataObject) this).GetDataHere(ref formatetc, ref medium);
}
else
{
Marshal.ThrowExceptionForHR(NativeMethods.DV_E_TYMED);
}
}catch (Exception ex)
{
medium = new STGMEDIUM();
ISLogger.Write("InputshareDataObject: " + ex.Message);
}
}
int IComDataObject.QueryGetData(ref FORMATETC formatetc) {
Debug.WriteLineIf(CompModSwitches.DataObject.TraceVerbose, "QueryGetData");
if (innerData is OleConverter) {
return ((OleConverter)innerData).OleDataObject.QueryGetData(ref formatetc);
}
if (formatetc.dwAspect == DVASPECT.DVASPECT_CONTENT) {
if (GetTymedUseable(formatetc.tymed)) {
if (formatetc.cfFormat == 0) {
Debug.WriteLineIf(CompModSwitches.DataObject.TraceVerbose, "QueryGetData::returning S_FALSE because cfFormat == 0");
return NativeMethods.S_FALSE;
}
else {
if (!GetDataPresent(DataFormats.GetFormat(formatetc.cfFormat).Name)) {
return (DV_E_FORMATETC);
}
}
}
else {
return (DV_E_TYMED);
}
}
else {
return (DV_E_DVASPECT);
}
#if DEBUG
int format = unchecked((ushort)formatetc.cfFormat);
Debug.WriteLineIf(CompModSwitches.DataObject.TraceVerbose, "QueryGetData::cfFormat " + format.ToString(CultureInfo.InvariantCulture) + " found");
#endif
return NativeMethods.S_OK;
}
/// <summary>
/// Initialize the context menu handler.
/// </summary>
/// <param name="pidlFolder">
/// A pointer to an ITEMIDLIST structure that uniquely identifies a folder.
/// </param>
/// <param name="pDataObj">
/// A pointer to an IDataObject interface object that can be used to retrieve
/// the objects being acted upon.
/// </param>
/// <param name="hKeyProgID">
/// The registry key for the file object or folder type.
/// </param>
public void Initialize(IntPtr pidlFolder, IntPtr pDataObj, IntPtr hKeyProgID)
{
if (pDataObj == IntPtr.Zero)
{
throw new ArgumentException();
}
FORMATETC fe = new FORMATETC();
fe.cfFormat = (short)CLIPFORMAT.CF_HDROP;
fe.ptd = IntPtr.Zero;
fe.dwAspect = DVASPECT.DVASPECT_CONTENT;
fe.lindex = -1;
fe.tymed = TYMED.TYMED_HGLOBAL;
STGMEDIUM stm = new STGMEDIUM();
// The pDataObj pointer contains the objects being acted upon. In this
// example, we get an HDROP handle for enumerating the selected files
// and folders.
IDataObject dataObject = (IDataObject)Marshal.GetObjectForIUnknown(pDataObj);
dataObject.GetData(ref fe, out stm);
try
{
// Get an HDROP handle.
IntPtr hDrop = stm.unionmember;
if (hDrop == IntPtr.Zero)
{
throw new ArgumentException();
}
// Determine how many files are involved in this operation.
uint nFiles = NativeMethods.DragQueryFile(hDrop, UInt32.MaxValue, null, 0);
// This code sample displays the custom context menu item when only
// one file is selected.
if (nFiles == 1)
{
// Get the path of the file.
StringBuilder fileName = new StringBuilder(260);
if (0 == NativeMethods.DragQueryFile(hDrop, 0, fileName,
fileName.Capacity))
{
Marshal.ThrowExceptionForHR(WinError.E_FAIL);
}
this.selectedFile = fileName.ToString();
}
else
{
Marshal.ThrowExceptionForHR(WinError.E_FAIL);
}
// [-or-]
// Enumerate the selected files and folders.
//if (nFiles > 0)
//{
// StringCollection selectedFiles = new StringCollection();
// StringBuilder fileName = new StringBuilder(260);
// for (uint i = 0; i < nFiles; i++)
// {
// // Get the next file name.
// if (0 != NativeMethods.DragQueryFile(hDrop, i, fileName,
// fileName.Capacity))
// {
// // Add the file name to the list.
// selectedFiles.Add(fileName.ToString());
// }
// }
//
// // If we did not find any files we can work with, throw
// // exception.
// if (selectedFiles.Count == 0)
// {
// Marshal.ThrowExceptionForHR(WinError.E_FAIL);
// }
//}
//else
//{
// Marshal.ThrowExceptionForHR(WinError.E_FAIL);
//}
}
finally
{
NativeMethods.ReleaseStgMedium(ref stm);
}
}
internal static bool IsFormatValid(FORMATETC[] formats)
{
if ((formats == null) || (formats.Length > 4))
{
return false;
}
for (int i = 0; i < formats.Length; i++)
{
short cfFormat = formats[i].cfFormat;
if (((cfFormat != 1) && (cfFormat != 13)) && ((cfFormat != DataFormats.GetFormat("System.String").Id) && (cfFormat != DataFormats.GetFormat("Csv").Id)))
{
return false;
}
}
return true;
}
// ------------------------------------------------------------------
/// <summary>
/// Extracts data of type <c>Dataformat.Html</c> from an <c>IDataObject</c> data container
/// This method shouldn't throw any exception but writes relevant exception informations in the debug window
/// </summary>
/// <param name="data">data container</param>
/// <returns>A byte[] array with the decoded string or null if the method fails</returns>
/// <remarks>Added 2006-06-12, <c>Uwe Keim</c>.</remarks>
private static byte[] getHtml(
System.Windows.Forms.IDataObject data)
{
var interopData = (System.Runtime.InteropServices.ComTypes.IDataObject)data;
var format =
new FORMATETC
{
cfFormat = ((short)DataFormats.GetFormat(DataFormats.Html).Id),
dwAspect = DVASPECT.DVASPECT_CONTENT,
lindex = (-1),
tymed = TYMED.TYMED_HGLOBAL
};
STGMEDIUM stgmedium;
stgmedium.tymed = TYMED.TYMED_HGLOBAL;
stgmedium.pUnkForRelease = null;
//try
//{
var queryResult = interopData.QueryGetData(ref format);
//}
//catch ( Exception exp )
//{
// Debug.WriteLine( "HtmlFromIDataObject.GetHtml -> QueryGetData(ref format) threw an exception: "
// + Environment.NewLine + exp.ToString() );
// return null;
//}
if (queryResult != 0)
{
//Debug.WriteLine(
// string.Format(
// @"HtmlFromIDataObject.GetHtml -> QueryGetData(ref format) returned a code != 0 code: {0}",
// queryResult));
return null;
}
//try
//{
interopData.GetData(ref format, out stgmedium);
//}
//catch ( Exception exp )
//{
// System.Diagnostics.Debug.WriteLine( "HtmlFromIDataObject.GetHtml -> GetData(ref format, out stgmedium) threw this exception: "
// + Environment.NewLine + exp.ToString() );
// return null;
//}
if (stgmedium.unionmember == IntPtr.Zero)
{
//Debug.WriteLine(
// @"HtmlFromIDataObject.GetHtml -> stgmedium.unionmember returned an IntPtr pointing to zero");
return null;
}
var pointer = stgmedium.unionmember;
var handleRef = new HandleRef(null, pointer);
byte[] rawArray;
try
{
var ptr1 = GlobalLock(handleRef);
var length = GlobalSize(handleRef);
rawArray = new byte[length];
Marshal.Copy(ptr1, rawArray, 0, length);
}
//catch ( Exception exp )
//{
// Debug.WriteLine( "HtmlFromIDataObject.GetHtml -> Html Import threw an exception: " + Environment.NewLine + exp.ToString() );
//}
finally
{
GlobalUnlock(handleRef);
}
return rawArray;
}
/// <include file='doc\DataObject.uex' path='docs/doc[@for="DataObject.OleConverter.GetDataFromOleHGLOBAL"]/*' />
/// <devdoc>
/// Uses HGLOBALs and retrieves the specified format from the bound IComDatabject.
/// </devdoc>
/// <internalonly/>
private Object GetDataFromOleHGLOBAL(string format) {
Debug.Assert(innerData != null, "You must have an innerData on all DataObjects");
FORMATETC formatetc = new FORMATETC();
STGMEDIUM medium = new STGMEDIUM();
formatetc.cfFormat = unchecked((short)(ushort)(DataFormats.GetFormat(format).Id));
formatetc.dwAspect = DVASPECT.DVASPECT_CONTENT;
formatetc.lindex = -1;
formatetc.tymed = TYMED.TYMED_HGLOBAL;
medium.tymed = TYMED.TYMED_HGLOBAL;
object data = null;
if (NativeMethods.S_OK == QueryGetDataUnsafe(ref formatetc)) {
try {
IntSecurity.UnmanagedCode.Assert();
try {
innerData.GetData(ref formatetc, out medium);
}
finally {
CodeAccessPermission.RevertAssert();
}
if (medium.unionmember != IntPtr.Zero) {
data = GetDataFromHGLOBLAL(format, medium.unionmember);
}
}
catch {
}
}
return data;
}