internal uint SetData(FORMATETC pformatetc, STGMEDIUM pmedium, bool release) { return E_NOTIMPL; }
int IVsSimpleObjectList2.GetClipboardFormat(uint index, uint grfFlags, FORMATETC[] pFormatetc, STGMEDIUM[] pMedium) { return VSConstants.E_NOTIMPL; }
void IDataObject.GetData(FORMATETC[] fmt, STGMEDIUM[] m) { STGMEDIUM retMedium = new STGMEDIUM(); if (fmt == null || fmt.Length < 1) return; foreach (DataCacheEntry e in this.entries) { if (e.Format.cfFormat == fmt[0].cfFormat /*|| fmt[0].cfFormat == InternalNativeMethods.CF_HDROP*/) { retMedium.tymed = e.Format.tymed; // Caller must delete the memory. retMedium.unionmember = DragDropHelper.CopyHGlobal(new IntPtr(e.Data)); break; } } if (m != null && m.Length > 0) m[0] = retMedium; }
/// <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. object odd = ComDataObjectExtensions.GetDropDescription((Runtime.InteropServices.ComTypes.IDataObject) data); if (odd != null) SetDropDescriptionIsDefault(data, false); }
private static extern int CopyStgMedium(ref STGMEDIUM pcstgmedSrc, ref STGMEDIUM pstgmedDest);
public void GetDataHere(ref FORMATETC format, ref STGMEDIUM medium) { throw new NotSupportedException(); }
public static extern void ReleaseStgMedium(ref STGMEDIUM pmedium);
/// <summary> /// Asks the given list item to renders a specific clipboard format that it supports. /// </summary> /// <param name="index"></param> /// <param name="grfFlags"></param> /// <param name="pFormatetc"></param> /// <param name="pMedium"></param> /// <returns></returns> public int GetClipboardFormat(uint index, uint grfFlags, FORMATETC[] pFormatetc, STGMEDIUM[] pMedium) { return VSConstants.E_NOTIMPL; }
public OleDataEntry(FORMATETC fmt, STGMEDIUM stg) { format = fmt; stgm = stg; }
public uint GetDataHere(ref FORMATETC pFormatetc, out STGMEDIUM pMedium) { Trace.WriteLine("GetDataHere"); pMedium = new STGMEDIUM(); return (uint)E_NOTIMPL; }
public uint SetData(ref FORMATETC a, ref STGMEDIUM b, bool fRelease) { //mpFormatetc = pFormatectIn; //mpmedium = pmedium; Trace.WriteLine("SetData"); return (int)S_OK; }
public uint GetData(ref FORMATETC pFormatetc, ref STGMEDIUM pMedium) { IntPtr hDst = mBitmap.GetHbitmap(); pMedium.tymed = (int)TYMED.TYMED_GDI; pMedium.unionmember = hDst; pMedium.pUnkForRelease = IntPtr.Zero; return (uint)S_OK; }
void IDataObject.GetData(FORMATETC[] fmt, STGMEDIUM[] m) { STGMEDIUM retMedium = new STGMEDIUM(); if (fmt == null || fmt.Length < 1) return; foreach (DataCacheEntry e in this.entries) { if (e.format.cfFormat == fmt[0].cfFormat) { retMedium.tymed = e.format.tymed; retMedium.unionmember = CopyHGlobal(new IntPtr(e.data)); break; } } if (m != null && m.Length > 0) m[0] = retMedium; }
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; }
/// <summary> /// Provides data to the client as it becomes available during asynchronous bind operations. /// </summary> void IBindStatusCallback.OnDataAvailable(BSCF grfBSCF, uint dwSize, ref FORMATETC pformatetc, ref STGMEDIUM pstgmed) { // never called by URLDownloadToFile LOG_UN("IBindStatusCallback", "OnDataAvailable"); }
internal static string[] GetFilenamesAnsi(NativeMethods.IDataObject data) { log.Debug("Getting filenames (ANSI)"); IntPtr ptrFgd = IntPtr.Zero; STGMEDIUM medium = new STGMEDIUM(); try { //Define FileGroupDescriptor format FORMATETC format = new FORMATETC(); format.cfFormat = (short)GetClipboardFormat("FileGroupDescriptor"); format.dwAspect = DVASPECT.DVASPECT_CONTENT; format.lindex = -1; format.ptd = IntPtr.Zero; format.tymed = TYMED.TYMED_ISTREAM | TYMED.TYMED_ISTORAGE | TYMED.TYMED_HGLOBAL; //Query if format exists in data if (data.QueryGetData(format) != NativeMethods.S_OK) { log.Debug("No filenames found"); return(null); } //Get data into medium int retVal = data.GetData(format, out medium); if (retVal != NativeMethods.S_OK) { throw new Exception(string.Format("Could not get FileGroupDescriptor format. Error returned: {0}", retVal)); } //Read medium into byte array log.Debug("Reading structure into memory stream"); byte[] bytes; using (MemoryStream stream = new MemoryStream()) { DataObjectHelper.ReadMediumIntoStream(medium, stream); bytes = new byte[stream.Length]; stream.Seek(0, SeekOrigin.Begin); stream.Read(bytes, 0, bytes.Length); } //Copy byte array into unmanaged memory log.Debug("Copying structure into unmanaged memory"); ptrFgd = Marshal.AllocHGlobal(bytes.Length); Marshal.Copy(bytes, 0, ptrFgd, bytes.Length); //Marshal unmanaged memory to a FILEGROUPDESCRIPTORA struct log.Debug("Marshaling unmanaged memory into FILEGROUPDESCRIPTORA struct"); NativeMethods.FILEGROUPDESCRIPTORA fgd = (NativeMethods.FILEGROUPDESCRIPTORA)Marshal.PtrToStructure(ptrFgd, typeof(NativeMethods.FILEGROUPDESCRIPTORA)); log.Debug(string.Format("Files found: {0}", fgd.cItems)); //Create an array to store file names string[] filenames = new string[fgd.cItems]; //Get the pointer to the first file descriptor IntPtr fdPtr = IntPtr.Add(ptrFgd, sizeof(uint)); //Loop for the number of files acording to the file group descriptor for (int fdIndex = 0; fdIndex < fgd.cItems; fdIndex++) { log.DebugFormat("Filenames found: {0}", string.Join(", ", filenames)); //Marshal pointer to a FILEDESCRIPTORA struct NativeMethods.FILEDESCRIPTORA fd = (NativeMethods.FILEDESCRIPTORA)Marshal.PtrToStructure(fdPtr, typeof(NativeMethods.FILEDESCRIPTORA)); //Get filename of file descriptor and put in array filenames[fdIndex] = fd.cFileName; //Move the file descriptor pointer to the next file descriptor fdPtr = IntPtr.Add(fdPtr, Marshal.SizeOf(fd)); } log.DebugFormat("Filenames found: {0}", string.Join(", ", filenames)); return(filenames); } finally { //Release all unmanaged objects Marshal.FreeHGlobal(ptrFgd); if (medium.pUnkForRelease == null) { NativeMethods.ReleaseStgMedium(ref medium); } } }
void IDataObject.GetData(ref FORMATETC format, out STGMEDIUM medium) { medium = new STGMEDIUM(); var hr = ((IDataObject)this).QueryGetData(ref format); if (NativeMethods.SUCCEEDED(hr)) { // Find the best match var formatCopy = format; // Cannot use ref or out parameter inside an anonymous method, lambda expression, or query expression DataObject dataObject = null; foreach (DataObject d in _dataObjects) { if ((d.FORMATETC.cfFormat == formatCopy.cfFormat) && (d.FORMATETC.dwAspect == formatCopy.dwAspect) && (0 != (d.FORMATETC.tymed & formatCopy.tymed) && (d.FORMATETC.lindex == formatCopy.lindex))) { dataObject = d; break; } } /* * var dataObject = _dataObjects * .Where(d => * (d.FORMATETC.cfFormat == formatCopy.cfFormat) && * (d.FORMATETC.dwAspect == formatCopy.dwAspect) && * (0 != (d.FORMATETC.tymed & formatCopy.tymed) && * (d.FORMATETC.lindex == formatCopy.lindex))) * .FirstOrDefault();*/ if (dataObject != null) { if (!IsAsynchronous && (FILEDESCRIPTORW == dataObject.FORMATETC.cfFormat) && !_inOperation) { // Enter the operation and call the start action _inOperation = true; if (null != _startAction) { _startAction(this); } } // Populate the STGMEDIUM medium.tymed = dataObject.FORMATETC.tymed; var result = dataObject.GetData(); // Possible call to user code hr = result.Item2; if (NativeMethods.SUCCEEDED(hr)) { medium.unionmember = result.Item1; } } else { // Couldn't find a match hr = NativeMethods.DV_E_FORMATETC; } } if (!NativeMethods.SUCCEEDED(hr)) // Not redundant; hr gets updated in the block above { Marshal.ThrowExceptionForHR(hr); } }
/// <summary> /// 初始化上下文菜单处理程序 /// </summary> /// <param name="pidlFolder"> /// 指向标识文件夹的 ITEMIDLIST 结构的指针. /// </param> /// <param name="pDataObj"> /// 一个指向 IDataObject 接口对象的指针可以用来检索对象. /// </param> /// <param name="hKeyProgID"> /// 对象或文件夹的文件类型的注册表项. /// </param> public void Initialize(IntPtr pidlFolder, IntPtr pDataObj, IntPtr hKeyProgID) { if (pDataObj == IntPtr.Zero) { throw new ArgumentException(); } selectedFiles.Clear(); 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(); // pDataObj 指针指向对象. 在这示例,我们得到一个HDROP的句柄的枚举在选定的文件和文件夹 IDataObject dataObject = (IDataObject)Marshal.GetObjectForIUnknown(pDataObj); dataObject.GetData(ref fe, out stm); try { // 取到HDROP句柄 IntPtr hDrop = stm.unionmember; if (hDrop == IntPtr.Zero) { throw new ArgumentException(); } //确定在此操作中涉及多少个文件. uint nFiles = NativeMethods.DragQueryFile(hDrop, UInt32.MaxValue, null, 0); //只有一个文件被选中时,示例代码将显示自定义上下文菜单项中. //if (nFiles == 1) //{ // //获取文件名. // StringBuilder fileName = new StringBuilder(260); // if (0 == NativeMethods.DragQueryFile(hDrop, 0, fileName, // fileName.Capacity)) // { // Marshal.ThrowExceptionForHR(WinError.E_FAIL); // } // this.selectedFile = fileName.ToString(); // selectedFiles.Add(this.selectedFile); //} //else //{ // Marshal.ThrowExceptionForHR(WinError.E_FAIL); //} // [-或者-] // 枚举被选中的文件和文件夹. if (nFiles > 0) { 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); } }
private static extern void ReleaseStgMedium(ref STGMEDIUM pmedium);
void System.Runtime.InteropServices.ComTypes.IDataObject.SetData(ref FORMATETC format, ref STGMEDIUM medium, bool release) { }
internal static extern void ReleaseStgMedium(ref STGMEDIUM 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); } }
/// <summary> /// Gets the specified data. /// </summary> /// <param name="format">The requested data format.</param> /// <param name="medium">When the function returns, contains the requested data.</param> /// <remarks>Differs from GetData only in that the STGMEDIUM storage is /// allocated and owned by the caller.</remarks> public void GetDataHere(ref FORMATETC format, ref STGMEDIUM medium) { // Locate the data KeyValuePair<FORMATETC, STGMEDIUM> dataEntry; if (GetDataEntry(ref format, out dataEntry)) { STGMEDIUM source = dataEntry.Value; medium = CopyMedium(ref source); return; } // Didn't find it. Return an empty data medium. medium = default(STGMEDIUM); }
override public bool GetMTEF() { bool bReturn = false; if (!sdk.Init()) { return(bReturn); } IDataObject dataObject = MathTypeSDK.getIDataObject(); if (dataObject == null) { sdk.DeInit(); return(bReturn); } FORMATETC formatEtc = new FORMATETC(); STGMEDIUM stgMedium = new STGMEDIUM(); try { // Setup the formatting information to use for the conversion. formatEtc.cfFormat = (Int16)DataFormats.GetFormat(strInTrans).Id; formatEtc.dwAspect = DVASPECT.DVASPECT_CONTENT; formatEtc.lindex = -1; formatEtc.ptd = (IntPtr)0; formatEtc.tymed = TYMED.TYMED_HGLOBAL; // Setup the MathML content to convert stgMedium.unionmember = Marshal.StringToHGlobalAuto(strEquation); stgMedium.tymed = TYMED.TYMED_HGLOBAL; stgMedium.pUnkForRelease = 0; // Perform the conversion dataObject.SetData(ref formatEtc, ref stgMedium, false); // Set the format for the output formatEtc.cfFormat = (Int16)DataFormats.GetFormat("MathType EF").Id; formatEtc.dwAspect = DVASPECT.DVASPECT_CONTENT; formatEtc.lindex = -1; formatEtc.ptd = (IntPtr)0; formatEtc.tymed = TYMED.TYMED_ISTORAGE; // Create a blank data structure to hold the converted result. stgMedium = new STGMEDIUM(); stgMedium.tymed = TYMED.TYMED_NULL; stgMedium.pUnkForRelease = 0; // Get the conversion result in MTEF format dataObject.GetData(ref formatEtc, out stgMedium); } catch (COMException e) { Console.WriteLine("MathML conversion to MathType threw an exception: " + Environment.NewLine + e.ToString()); sdk.DeInit(); return(bReturn); } // The pointer now becomes a Handle reference. HandleRef handleRef = new HandleRef(null, stgMedium.unionmember); try { // Lock in the handle to get the pointer to the data IntPtr ptrToHandle = MathTypeSDK.GlobalLock(handleRef); // Get the size of the memory block m_iMTEF_Length = MathTypeSDK.GlobalSize(handleRef); // New an array of bytes and Marshal the data across. m_bMTEF = new byte[m_iMTEF_Length]; Marshal.Copy(ptrToHandle, m_bMTEF, 0, m_iMTEF_Length); m_strMTEF = System.Text.ASCIIEncoding.ASCII.GetString(m_bMTEF); bReturn = true; } catch (Exception e) { Console.WriteLine("Generation of image from MathType failed: " + Environment.NewLine + e.ToString()); } finally { MathTypeSDK.GlobalUnlock(handleRef); } sdk.DeInit(); return(bReturn); }
/// <summary> /// Creates a copy of the STGMEDIUM structure. /// </summary> /// <param name="medium">The data to copy.</param> /// <returns>The copied data.</returns> private STGMEDIUM CopyMedium(ref STGMEDIUM medium) { STGMEDIUM sm = new STGMEDIUM(); int hr = CopyStgMedium(ref medium, ref sm); if (hr != 0) throw Marshal.GetExceptionForHR(hr); return sm; }
void IDataObject.GetData(FORMATETC[] fmt, STGMEDIUM[] m) { STGMEDIUM retMedium = new STGMEDIUM(); foreach (DataCacheEntry e in this.entries) { if (e.format.cfFormat == fmt[0].cfFormat) { retMedium.tymed = e.format.tymed; retMedium.unionmember = CopyHGlobal(e.data); break; } } m[0] = retMedium; }
void IDataObject.GetData(FORMATETC[] fmt, STGMEDIUM[] m) { STGMEDIUM retMedium = new STGMEDIUM(); if(fmt == null || fmt.Length < 1) return; SafeGlobalAllocHandle copy = null; foreach(DataCacheEntry e in this.entries) { if(e.Format.cfFormat == fmt[0].cfFormat /*|| fmt[0].cfFormat == InternalNativeMethods.CF_HDROP*/) { retMedium.tymed = e.Format.tymed; // Caller must delete the memory. copy = DragDropHelper.CopyHGlobal(e.Data); retMedium.unionmember = copy.DangerousGetHandle(); break; } } if (m != null && m.Length > 0) { m[0] = retMedium; if (copy != null) copy.SetHandleAsInvalid(); } }
void IDataObject.GetDataHere(FORMATETC[] fmt, STGMEDIUM[] m) { throw new NotImplementedException(); }
void IDataObject.SetData(FORMATETC[] fmt, STGMEDIUM[] m, int fRelease) { }
void IDataObject.SetData(FORMATETC[] fmt, STGMEDIUM[] m, int fRelease) { throw new NotImplementedException(); }
internal static void GetSelectedItems(IntPtr pidlFolder, IntPtr pDataObj, IntPtr hKeyProgID, ref List <String> SelectedItems, ref bool isClickOnEmptyArea) { if (pDataObj == IntPtr.Zero && pidlFolder == IntPtr.Zero) { throw new ArgumentException(); } else if (pDataObj == IntPtr.Zero) { //User Click on Empty Area of a Folder, pDataObj is empty while pidlFolder is the current path StringBuilder sb = new StringBuilder(260); if (!NativeMethods.SHGetPathFromIDListW(pidlFolder, sb)) { Marshal.ThrowExceptionForHR(WinError.E_FAIL); } else { isClickOnEmptyArea = true; SelectedItems = new List <string>(); SelectedItems.Add(sb.ToString()); } } else { //User actually select some item, pDataObj is the list while pidlFolder is empty isClickOnEmptyArea = false; 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(); IDataObject dataObject = (IDataObject)Marshal.GetObjectForIUnknown(pDataObj); dataObject.GetData(ref fe, out stm); try { IntPtr hDrop = stm.unionmember; if (hDrop == IntPtr.Zero) { throw new ArgumentException(); } uint nFiles = NativeMethods.DragQueryFile(hDrop, UInt32.MaxValue, null, 0); if (nFiles == 0) { Marshal.ThrowExceptionForHR(WinError.E_FAIL); } SelectedItems = new List <string>(); for (int i = 0; i < nFiles; i++) { StringBuilder sb = new StringBuilder(260); if (NativeMethods.DragQueryFile(hDrop, (uint)i, sb, sb.Capacity) == 0) { Marshal.ThrowExceptionForHR(WinError.E_FAIL); } else { SelectedItems.Add(sb.ToString()); } } } finally { NativeMethods.ReleaseStgMedium(ref stm); } } }
void CopyStgMedium(IntPtr cfFormat, ref STGMEDIUM lpDest, ref STGMEDIUM lpSource) { /* STGMEDIUM appears to be messed up... if (lpDest.tymed == TYMED_NULL) { Debug.Assert(lpSource.tymed != TYMED_NULL); switch (lpSource.tymed) { case TYMED_ENHMF: case TYMED_HGLOBAL: lpDest.tymed = lpSource.tymed; lpDest.hGlobal = NULL; break; case TYMED_ISTREAM: lpDest.pstm = lpSource.pstm; lpDest.pstm.AddRef(); lpDest.tymed = TYMED_ISTREAM; return TRUE; case TYMED_ISTORAGE: lpDest.pstg = lpSource.pstg; lpDest.pstg.AddRef(); lpDest.tymed = TYMED_ISTORAGE; return TRUE; case TYMED_MFPICT: { // copy LPMETAFILEPICT struct + embedded HMETAFILE HGLOBAL hDest = ::CopyGlobalMemory(NULL, lpSource.hGlobal); if (hDest == NULL) return FALSE; LPMETAFILEPICT lpPict = (LPMETAFILEPICT)::GlobalLock(hDest); ASSERT(lpPict != NULL); lpPict.hMF = ::CopyMetaFile(lpPict.hMF, NULL); if (lpPict.hMF == NULL) { ::GlobalUnlock(hDest); ::GlobalFree(hDest); return FALSE; } ::GlobalUnlock(hDest); // fill STGMEDIUM struct lpDest.hGlobal = hDest; lpDest.tymed = TYMED_MFPICT; } return TRUE; case TYMED_GDI: lpDest.tymed = TYMED_GDI; lpDest.hGlobal = NULL; break; case TYMED_FILE: { USES_CONVERSION; lpDest.tymed = TYMED_FILE; ASSERT(lpSource.lpszFileName != NULL); UINT cbSrc = (int)ocslen(lpSource.lpszFileName); LPOLESTR szFileName = (LPOLESTR)CoTaskMemAlloc(cbSrc*sizeof(OLECHAR)); lpDest.lpszFileName = szFileName; if (szFileName == NULL) return FALSE; memcpy(szFileName, lpSource.lpszFileName, (cbSrc+1)*sizeof(OLECHAR)); return TRUE; } // unable to create + copy other TYMEDs default: return FALSE; } } ASSERT(lpDest.tymed == lpSource.tymed); switch (lpSource.tymed) { case TYMED_HGLOBAL: { HGLOBAL hDest = ::CopyGlobalMemory(lpDest.hGlobal, lpSource.hGlobal); if (hDest == NULL) return FALSE; lpDest.hGlobal = hDest; } return TRUE; case TYMED_ISTREAM: { ASSERT(lpDest.pstm != NULL); ASSERT(lpSource.pstm != NULL); // get the size of the source stream STATSTG stat; if (lpSource.pstm.Stat(&stat, STATFLAG_NONAME) != S_OK) { // unable to get size of source stream return FALSE; } ASSERT(stat.pwcsName == NULL); // always seek to zero before copy LARGE_INTEGER zero = { 0, 0 }; lpDest.pstm.Seek(zero, STREAM_SEEK_SET, NULL); lpSource.pstm.Seek(zero, STREAM_SEEK_SET, NULL); // copy source to destination if (lpSource.pstm.CopyTo(lpDest.pstm, stat.cbSize, NULL, NULL) != NULL) { // copy from source to dest failed return FALSE; } // always seek to zero after copy lpDest.pstm.Seek(zero, STREAM_SEEK_SET, NULL); lpSource.pstm.Seek(zero, STREAM_SEEK_SET, NULL); } return TRUE; case TYMED_ISTORAGE: { ASSERT(lpDest.pstg != NULL); ASSERT(lpSource.pstg != NULL); // just copy source to destination if (lpSource.pstg.CopyTo(0, NULL, NULL, lpDest.pstg) != S_OK) return FALSE; } return TRUE; case TYMED_FILE: { USES_CONVERSION; ASSERT(lpSource.lpszFileName != NULL); ASSERT(lpDest.lpszFileName != NULL); return CopyFile(OLE2T(lpSource.lpszFileName), OLE2T(lpDest.lpszFileName), FALSE); } case TYMED_ENHMF: case TYMED_GDI: { ASSERT(sizeof(HGLOBAL) == sizeof(HENHMETAFILE)); // with TYMED_GDI cannot copy into existing HANDLE if (lpDest.hGlobal != NULL) return FALSE; // otherwise, use OleDuplicateData for the copy lpDest.hGlobal = OleDuplicateData(lpSource.hGlobal, cfFormat, 0); if (lpDest.hGlobal == NULL) return FALSE; } return TRUE; // other TYMEDs cannot be copied default: return FALSE; } */ }
/// <summary> /// Gets the specified data. /// </summary> /// <param name="format">The requested data format.</param> /// <param name="medium">When the function returns, contains the requested data.</param> public void GetData(ref FORMATETC format, out STGMEDIUM medium) { medium = new STGMEDIUM(); GetDataHere(ref format, ref medium); }
void System.Runtime.InteropServices.ComTypes.IDataObject.GetData(ref FORMATETC format, out STGMEDIUM medium) { medium = new STGMEDIUM(); var hr = ((System.Runtime.InteropServices.ComTypes.IDataObject) this).QueryGetData(ref format); if (NativeMethods.SUCCEEDED(hr)) { // Find the best match var formatCopy = format; // Cannot use ref or out parameter inside an anonymous method, lambda expression, or query expression var dataObject = _dataObjects .Where(d => (d.FORMATETC.cfFormat == formatCopy.cfFormat) && (d.FORMATETC.dwAspect == formatCopy.dwAspect) && (0 != (d.FORMATETC.tymed & formatCopy.tymed) && (d.FORMATETC.lindex == formatCopy.lindex))) .FirstOrDefault(); if (dataObject != null) { if (!IsAsynchronous && (FILEDESCRIPTORW == dataObject.FORMATETC.cfFormat) && !_inOperation) { // Enter the operation and call the start action _inOperation = true; if (null != _startAction) { _startAction(this); } } // Populate the STGMEDIUM medium.tymed = dataObject.FORMATETC.tymed; var result = dataObject.GetData(); // Possible call to user code hr = result.Item2; if (NativeMethods.SUCCEEDED(hr)) { medium.unionmember = result.Item1; } } else { // Couldn't find a match hr = NativeMethods.DV_E_FORMATETC; } } if (!NativeMethods.SUCCEEDED(hr)) // Not redundant; hr gets updated in the block above { Marshal.ThrowExceptionForHR(hr); // KFreon: Can fail here with FORMATETC problem when running through debugger. Use Ctrl+F5 to run without debugger. } }
/// <summary> /// Obtains data from a source data object. /// </summary> /// <param name="format">A pointer to a FORMATETC structure that defines the format, medium, and target device to use when passing the data.</param> /// <param name="medium">A STGMEDIUM that defines the storage medium containing the data being transferred.</param> void IDataObject.GetDataHere(ref FORMATETC format, ref STGMEDIUM medium) { throw new NotImplementedException(); }
/// <summary> /// Obtains data from a source data object. /// </summary> /// <param name="format">A pointer to a FORMATETC structure that defines the format, medium, and target device to use when passing the data.</param> /// <param name="medium">A STGMEDIUM that defines the storage medium containing the data being transferred.</param> void System.Runtime.InteropServices.ComTypes.IDataObject.GetDataHere(ref FORMATETC format, ref STGMEDIUM medium) { throw new NotImplementedException(); }
void System.Runtime.InteropServices.ComTypes.IDataObject.SetData(ref FORMATETC formatIn, ref STGMEDIUM medium, bool release) { var handled = false; if ((formatIn.dwAspect == DVASPECT.DVASPECT_CONTENT) && (formatIn.tymed == TYMED.TYMED_HGLOBAL) && (medium.tymed == formatIn.tymed)) { // Supported format; capture the data var ptr = NativeMethods.GlobalLock(medium.unionmember); if (IntPtr.Zero != ptr) { try { var length = NativeMethods.GlobalSize(ptr).ToInt32(); var data = new byte[length]; Marshal.Copy(ptr, data, 0, length); // Store it in our own format SetData(formatIn.cfFormat, data); handled = true; } finally { NativeMethods.GlobalUnlock(medium.unionmember); } } // Release memory if we now own it if (release) { Marshal.FreeHGlobal(medium.unionmember); } } // Handle synchronous mode if (!IsAsynchronous && (PERFORMEDDROPEFFECT == formatIn.cfFormat) && _inOperation) { // Call the end action and exit the operation if (null != _endAction) { _endAction(this); } _inOperation = false; } // Throw if unhandled if (!handled) { throw new NotImplementedException(); } }
/// <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); } }
/// <summary> /// Retrieves the data associated with the specified data format at the specified index. /// </summary> /// <param name="format">The format of the data to retrieve. See <see cref="T:System.Windows.Forms.DataFormats"></see> for predefined formats.</param> /// <param name="index">The index of the data to retrieve.</param> /// <returns> /// A <see cref="MemoryStream"/> containing the raw data for the specified data format at the specified index. /// </returns> public MemoryStream GetData(string format, int index) { //create a FORMATETC struct to request the data with FORMATETC formatetc = new FORMATETC(); formatetc.cfFormat = (short)DataFormats.GetFormat(format).Id; formatetc.dwAspect = DVASPECT.DVASPECT_CONTENT; formatetc.lindex = index; formatetc.ptd = new IntPtr(0); formatetc.tymed = TYMED.TYMED_ISTREAM | TYMED.TYMED_ISTORAGE | TYMED.TYMED_HGLOBAL; //create STGMEDIUM to output request results into STGMEDIUM medium = new STGMEDIUM(); //using the Com IDataObject interface get the data using the defined FORMATETC this.comUnderlyingDataObject.GetData(ref formatetc, out medium); //retrieve the data depending on the returned store type switch (medium.tymed) { case TYMED.TYMED_ISTORAGE: //to handle a IStorage it needs to be written into a second unmanaged //memory mapped storage and then the data can be read from memory into //a managed byte and returned as a MemoryStream Win32.NativeMethods.IStorage iStorage = null; Win32.NativeMethods.IStorage iStorage2 = null; Win32.NativeMethods.ILockBytes iLockBytes = null; System.Runtime.InteropServices.ComTypes.STATSTG iLockBytesStat; try { //marshal the returned pointer to a IStorage object iStorage = (Win32.NativeMethods.IStorage)Marshal.GetObjectForIUnknown(medium.unionmember); Marshal.Release(medium.unionmember); //create a ILockBytes (unmanaged byte array) and then create a IStorage using the byte array as a backing store iLockBytes = Win32.NativeMethods.CreateILockBytesOnHGlobal(IntPtr.Zero, true); iStorage2 = Win32.NativeMethods.StgCreateDocfileOnILockBytes(iLockBytes, 0x00001012, 0); //copy the returned IStorage into the new IStorage iStorage.CopyTo(0, null, IntPtr.Zero, iStorage2); iLockBytes.Flush(); iStorage2.Commit(0); //get the STATSTG of the ILockBytes to determine how many bytes were written to it iLockBytesStat = new System.Runtime.InteropServices.ComTypes.STATSTG(); iLockBytes.Stat(out iLockBytesStat, 1); int iLockBytesSize = (int)iLockBytesStat.cbSize; //read the data from the ILockBytes (unmanaged byte array) into a managed byte array byte[] iLockBytesContent = new byte[iLockBytesSize]; iLockBytes.ReadAt(0, iLockBytesContent, iLockBytesContent.Length, null); //wrapped the managed byte array into a memory stream and return it return(new MemoryStream(iLockBytesContent)); } finally { //release all unmanaged objects Marshal.ReleaseComObject(iStorage2); Marshal.ReleaseComObject(iLockBytes); Marshal.ReleaseComObject(iStorage); } case TYMED.TYMED_ISTREAM: //to handle a IStream it needs to be read into a managed byte and //returned as a MemoryStream IStream iStream = null; System.Runtime.InteropServices.ComTypes.STATSTG iStreamStat; try { //marshal the returned pointer to a IStream object iStream = (IStream)Marshal.GetObjectForIUnknown(medium.unionmember); Marshal.Release(medium.unionmember); //get the STATSTG of the IStream to determine how many bytes are in it iStreamStat = new System.Runtime.InteropServices.ComTypes.STATSTG(); iStream.Stat(out iStreamStat, 0); int iStreamSize = (int)iStreamStat.cbSize; //read the data from the IStream into a managed byte array byte[] iStreamContent = new byte[iStreamSize]; iStream.Read(iStreamContent, iStreamContent.Length, IntPtr.Zero); //wrapped the managed byte array into a memory stream and return it return(new MemoryStream(iStreamContent)); } finally { //release all unmanaged objects Marshal.ReleaseComObject(iStream); } case TYMED.TYMED_HGLOBAL: //to handle a HGlobal the exisitng "GetDataFromHGLOBLAL" method is invoked via //reflection return((MemoryStream)this.getDataFromHGLOBLALMethod.Invoke(this.oleUnderlyingDataObject, new object[] { DataFormats.GetFormat((short)formatetc.cfFormat).Name, medium.unionmember })); } return(null); }
internal static uint GetDataHere(IntPtr @this, ref FORMATETC pformatetc, ref STGMEDIUM pmedium) { return(DV_E_FORMATETC); }
/// <summary> /// Serializes managed data to an HGLOBAL. /// </summary> /// <param name="data">The managed data object.</param> /// <returns>An STGMEDIUM pointing to the allocated HGLOBAL.</returns> private static void GetMediumFromObject(object data, out STGMEDIUM medium) { // We'll serialize to a managed stream temporarily MemoryStream stream = new MemoryStream(); // Write an indentifying stamp, so we can recognize this as custom // marshaled data. stream.Write(ManagedDataStamp.ToByteArray(), 0, Marshal.SizeOf(typeof (Guid))); // Now serialize the data. Note, if the data is not directly serializable, // we'll try type conversion. Also, we serialize the type. That way, // during deserialization, we know which type to convert back to, if // appropriate. BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(stream, data.GetType()); formatter.Serialize(stream, GetAsSerializable(data)); // Now copy to an HGLOBAL byte[] bytes = stream.GetBuffer(); IntPtr p = Marshal.AllocHGlobal(bytes.Length); try { Marshal.Copy(bytes, 0, p, bytes.Length); } catch { // Make sure to free the memory on exceptions Marshal.FreeHGlobal(p); throw; } // Now allocate an STGMEDIUM to wrap the HGLOBAL medium.unionmember = p; medium.tymed = TYMED.TYMED_HGLOBAL; medium.pUnkForRelease = null; }
internal static uint SetData(IntPtr this_, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, bool release) { return(E_NOTIMPL); }
internal uint GetDataHere(FORMATETC pformatetc, ref STGMEDIUM pmedium) { return(E_NOTIMPL); }
/// <summary> /// Sets data in the specified format into storage. /// </summary> /// <param name="formatIn">The format of the data.</param> /// <param name="medium">The data.</param> /// <param name="release">If true, ownership of the medium's memory will be transferred /// to this object. If false, a copy of the medium will be created and maintained, and /// the caller is responsible for the memory of the medium it provided.</param> public void SetData(ref FORMATETC formatIn, ref STGMEDIUM medium, bool release) { // If the format exists in our storage, remove it prior to resetting it foreach (KeyValuePair<FORMATETC, STGMEDIUM> pair in storage) { if ((pair.Key.tymed & formatIn.tymed) > 0 && pair.Key.dwAspect == formatIn.dwAspect && pair.Key.cfFormat == formatIn.cfFormat) { STGMEDIUM releaseMedium = pair.Value; ReleaseStgMedium(ref releaseMedium); storage.Remove(pair); break; } } // If release is true, we'll take ownership of the medium. // If not, we'll make a copy of it. STGMEDIUM sm = medium; if (!release) sm = CopyMedium(ref medium); // Add it to the internal storage KeyValuePair<FORMATETC, STGMEDIUM> addPair = new KeyValuePair<FORMATETC, STGMEDIUM>(formatIn, sm); storage.Add(addPair); RaiseDataChanged(ref addPair); }
internal uint SetData(FORMATETC pformatetc, STGMEDIUM pmedium, bool release) { return(E_NOTIMPL); }
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); }
public static STGMEDIUM GetData(Microsoft.VisualStudio.OLE.Interop.IDataObject dataObject, ref FORMATETC fmtetc) { if (dataObject == null) throw new ArgumentNullException("dataObject"); FORMATETC[] af = new FORMATETC[1]; af[0] = fmtetc; STGMEDIUM[] sm = new STGMEDIUM[1]; dataObject.GetData(af, sm); fmtetc = af[0]; return sm[0]; }
IntPtr IBindStatusCallback.OnDataAvailable(uint grfBSCF, uint dwSize, ref FORMATETC pformatetc, ref STGMEDIUM pstgmed) { if (pstgmed.tymed != TYMED.TYMED_ISTREAM) { throw new InvalidOperationException("This callback handler only supports IStreams."); } // assume an IStream has been requested in BindMonikerToObject IStream stream = (IStream)Marshal.GetObjectForIUnknown(pstgmed.unionmember); IntPtr hresult; bool shouldContinue = true; do { byte[] buffer = new byte[bufferSize]; IntPtr pBytesRead = Marshal.AllocHGlobal(sizeof(uint)); hresult = stream.Read(buffer, buffer.Length, pBytesRead); uint bytesRead = (uint)Marshal.PtrToStructure(pBytesRead, typeof(uint)); Marshal.FreeHGlobal(pBytesRead); if (bytesRead > 0) { shouldContinue = viewEvents.OnDataAvailable(buffer, (int)bytesRead); } //if (HResults.Equals(hresult, HResults.E_PENDING)) //{ // Thread.Sleep(1000); // hresult = HResults.S_OK; //} } while (shouldContinue && HResults.Succeeded(hresult) && !HResults.Equals(hresult, HResults.S_FALSE)); Marshal.ReleaseComObject(stream); if (!shouldContinue) { Abort(); } if (!HResults.Succeeded(hresult)) { return(hresult); } return(HResults.S_OK); }
� � public static extern void ReleaseStgMedium(ref STGMEDIUM pmedium);
private static MemoryStream GetFileContentFromIStream(this System.Windows.Forms.IDataObject data, STGMEDIUM medium) { var iStream = (IStream)Marshal.GetObjectForIUnknown(medium.unionmember); Marshal.Release(medium.unionmember); var iStreamStat = new System.Runtime.InteropServices.ComTypes.STATSTG(); iStream.Stat(out iStreamStat, 0); var content = new byte[(int)iStreamStat.cbSize]; iStream.Read(content, content.Length, IntPtr.Zero); return(new MemoryStream(content)); }
/// <summary> /// Asks the given list item to renders a specific clipboard format that it supports. /// </summary> /// <param name="index"></param> /// <param name="grfFlags"></param> /// <param name="pFormatetc"></param> /// <param name="pMedium"></param> /// <returns></returns> public int GetClipboardFormat(uint index, uint grfFlags, FORMATETC[] pFormatetc, STGMEDIUM[] pMedium) { throw new NotImplementedException(); }
private static MemoryStream GetFileContentFromHGlobal(this System.Windows.Forms.IDataObject data, STGMEDIUM medium) { var innerDataField = data.GetType().GetField("innerData", BindingFlags.NonPublic | BindingFlags.Instance); var oldData = (System.Windows.Forms.IDataObject)innerDataField.GetValue(data); var getDataFromHGLOBLALMethod = oldData.GetType().GetMethod("GetDataFromHGLOBLAL", BindingFlags.NonPublic | BindingFlags.Instance); return((MemoryStream)getDataFromHGLOBLALMethod.Invoke(oldData, new object[] { "FileContents", medium.unionmember })); }
void IDataObject.GetDataHere(FORMATETC[] fmt, STGMEDIUM[] m) { }
public int GetDataHere(ref FORMATETC format, ref STGMEDIUM medium) { log.DebugFormat("IDataObject.QueryGetData called -- cfFormat {0} dwAspect {1} lindex {2} ptd {3} tymed {4}", format.cfFormat, format.dwAspect, format.lindex, format.ptd, format.tymed); return(NativeMethods.E_NOTIMPL); }
public static STGMEDIUM GetData(Microsoft.VisualStudio.OLE.Interop.IDataObject pDataObject, ref FORMATETC fmtetc) { FORMATETC[] af = new FORMATETC[1]; af[0] = fmtetc; STGMEDIUM[] sm = new STGMEDIUM[1]; pDataObject.GetData(af, sm); fmtetc = af[0]; return sm[0]; }
internal uint GetDataHere(FORMATETC pformatetc, ref STGMEDIUM pmedium) { return E_NOTIMPL; }