/// <summary> /// Determines whether the data object is capable of rendering the data described /// in the passed clipboard format and storage type(s). Objects attempting a /// paste or drop operation can call this method before calling GetData /// to get an indication of whether the operation may be successful /// </summary> /// <param name="clipFormat">Name of clipboard format requested</param> /// <param name="types">type(s) requested</param> /// <returns>true if the subseqent call to GetData would likely be /// successful, otherwise false</returns> public bool QueryGetData(string clipFormat, TYMED types) { // populate contents of FORMATETC structure FORMATETC formatEtc = new FORMATETC(); OleDataObjectHelper.PopulateFORMATETC(clipFormat, types, ref formatEtc); // try to successfully query for the data int result = m_dataObject.QueryGetData(ref formatEtc); // data is available if (result == HRESULT.S_OK) { return(true); } // data is not available else if (result == DV_E.FORMATETC) { return(false); } // unexpected error else { Marshal.ThrowExceptionForHR(result); return(false); // keep compiler happy } }
/// <summary> /// Attempts to create a new HTMLData. This can return null if the DataObject /// couldn't be created based upon the IDataObject. /// </summary> /// <param name="iDataObject">The IDataObject from which to create the HTML Data Object</param> /// <returns>The HTMLData, null if it couldn't be created.</returns> public static HTMLData Create(IDataObject iDataObject) { string[] loser = iDataObject.GetFormats(); if (OleDataObjectHelper.GetDataPresentSafe(iDataObject, DataFormats.Html)) { try { HTMLData data = new HTMLData(iDataObject, null); return(string.IsNullOrEmpty(data.HTML) ? null : data); } catch (FormatException) { // EML files with HTML inside of them report that they are HTML // However, when we try to read the format, we have problems reading it // So we will skip loading html that we cannot load return(null); } } else if (HtmlDocumentClassFormatPresent(iDataObject)) { return(new HTMLData(iDataObject, (IHTMLDocument2)iDataObject.GetData(typeof(HTMLDocumentClass)))); } else { return(null); } }
/// <summary> /// Creates an ImageData /// </summary> /// <param name="iDataObject">The IDataObject from which to create the ImageData</param> /// <returns>The ImageData, null if no ImageData could be created</returns> public static ImageData Create(IDataObject iDataObject) { if (!OleDataObjectHelper.GetDataPresentSafe(iDataObject, DataFormats.Dib) && !OleDataObjectHelper.GetDataPresentSafe(iDataObject, DataFormats.EnhancedMetafile)) { return(null); } else { return(new ImageData(iDataObject)); } }
public static LightWeightHTMLDocumentData Create(IDataObject iDataObject) { string[] loser = iDataObject.GetFormats(); if (OleDataObjectHelper.GetDataPresentSafe(iDataObject, LightWeightHTMLDataObject.LIGHTWEIGHTHTMLDOCUMENTFORMAT)) { LightWeightHTMLDocument document = (LightWeightHTMLDocument)iDataObject.GetData(LightWeightHTMLDataObject.LIGHTWEIGHTHTMLDOCUMENTFORMAT); return(new LightWeightHTMLDocumentData(document)); } else { return(null); } }
/// <summary> /// Returns a list of FileItemFormats for a given dataobject /// </summary> private static ArrayList GetFormatsForDataObject(IDataObject dataObject) { // Mozilla often time is very sketchy about their filedrops. They // may place null in the filedrop format, or they may place paths // to files that are highly transient and may or may not be available // when you need then (many images will get reset to 0 byte files) // As a result of this, we prefer FileContents when using Mozilla if (OleDataObjectHelper.GetDataPresentSafe(dataObject, MOZILLA_MARKER)) { return(mozillaFileItemFormats); } else { return(fileItemFormats); } }
/// <summary> /// Creates a TextData from an IDataObject /// </summary> /// <param name="iDataObject">The IDataObject from which to create a TextData</param> /// <returns>The TextData, null if no TextData could be created.</returns> public static TextData Create(IDataObject iDataObject) { // Note: Using getData or getDataPresent here will sometimes return text // even when the text isn't in the list of formats exposed by getFormats foreach (string format in iDataObject.GetFormats()) { if (format == DataFormats.UnicodeText || format == DataFormats.Text || format == DataFormats.StringFormat) { // Suppress the text from an outlook data object, the text is useless if (OleDataObjectHelper.GetDataPresentSafe(iDataObject, OUTLOOK_FORMAT_IGNORE_TEXT)) { return(null); } return(new TextData(iDataObject)); } } return(null); }
/// <summary> /// Creates a URLData based upon an IDataObject /// </summary> /// <param name="iDataObject">The IDataObject from which to create the URLData</param> /// <returns>The URLData, null if no URLData could be created</returns> public static URLData Create(IDataObject iDataObject) { // WinLive Bug 198371: Look at rolling the fix for WinLive 182698 into the OleDataObjectHelper.GetDataPresentSafe method // For now, we keep the changes targeted. bool canGetDataPresentDirectlyFromIDataObject = false; try { canGetDataPresentDirectlyFromIDataObject = iDataObject.GetDataPresent(DataFormatsEx.URLFormat) && iDataObject.GetDataPresent(DataFormatsEx.FileGroupDescriptorWFormat); } catch (Exception e) { Debug.Fail(e.ToString()); } // Validate required format // WinLive Bug 182698: Assert when pasting a hyperlink from IE if (canGetDataPresentDirectlyFromIDataObject && OleDataObjectHelper.GetDataPresentSafe(iDataObject, DataFormatsEx.URLFormat) && OleDataObjectHelper.GetDataPresentSafe(iDataObject, DataFormatsEx.FileGroupDescriptorWFormat)) { return(new URLData(iDataObject)); } else { //check to see if the dataObject contains a single .url file, //if so, create the URLData from that. FileData fileData = FileData.Create(iDataObject); if (fileData != null && fileData.Files.Length == 1) { string filePath = fileData.Files[0].ContentsPath; if (PathHelper.IsPathUrlFile(filePath)) { URLData urlData = new URLData(iDataObject, UrlHelper.GetUrlFromShortCutFile(filePath), Path.GetFileNameWithoutExtension(filePath)); urlData.DateCreated = File.GetCreationTime(filePath); urlData.DateModified = File.GetLastWriteTime(filePath); return(urlData); } } } return(null); }
/// <summary> /// Does the passed data object have this format? /// </summary> /// <param name="dataObject">data object</param> /// <returns>true if the data object has the format, otherwise false</returns> public bool CanCreateFrom(IDataObject dataObject) { return(OleDataObjectHelper.GetDataPresentSafe(dataObject, DataFormats.FileDrop) && dataObject.GetData(DataFormats.FileDrop) != null); }
/// <summary> /// Does the passed data object have this format? /// </summary> /// <param name="dataObject">data object</param> /// <returns>true if the data object has the format, otherwise false</returns> public bool CanCreateFrom(IDataObject dataObject) { return(OleDataObjectHelper.GetDataPresentSafe(dataObject, typeof(FileItem[]))); }
/// <summary> /// Extract the date from within an OleDataObject. Pass in the requested /// clipboard format and type (or types ORed together) that you want /// the data in. The method will return an OleStgMedium for the type(s) /// requested if it is available, otherwise it will return null. /// If a single type is requested then the return value can be safely /// cast to the requested OleStgMedium subclasss. If multiple types /// are requested then the return value will represent the object's /// preferred storage representation and client code will need to use /// the 'is' operator to determine what type was returned. /// </summary> /// <param name="lindex">Index of item to retreive</param> /// <param name="clipFormat">Name of clipboard format requested</param> /// <param name="types">type(s) requested</param> /// <returns>OleStgMedium instance if format and requested storage type /// are available, otherwise null</returns> public OleStgMedium GetData(int lindex, string clipFormat, TYMED types) { // populate contents of FORMATETC structure FORMATETC formatEtc = new FORMATETC(); OleDataObjectHelper.PopulateFORMATETC(lindex, clipFormat, types, ref formatEtc); // attempt to get the data using the requested format STGMEDIUM stgMedium = new STGMEDIUM(); if (m_dataObject != null) { int result = m_dataObject.GetData(ref formatEtc, ref stgMedium); // check for errors if (result != HRESULT.S_OK) { // data format not supported (expected error condition) if (result == DV_E.FORMATETC) { return(null); } // unexpected error condition else { Marshal.ThrowExceptionForHR(result); } } // return the correct OleStgMedium subclass depending upon the type switch (stgMedium.tymed) { case TYMED.NULL: return(null); case TYMED.HGLOBAL: return(new OleStgMediumHGLOBAL(stgMedium)); case TYMED.FILE: return(new OleStgMediumFILE(stgMedium)); case TYMED.GDI: return(new OleStgMediumGDI(stgMedium)); case TYMED.MFPICT: return(new OleStgMediumMFPICT(stgMedium)); case TYMED.ENHMF: return(new OleStgMediumENHMF(stgMedium)); case TYMED.ISTREAM: return(new OleStgMediumISTREAM(stgMedium)); case TYMED.ISTORAGE: return(new OleStgMediumISTORAGE(stgMedium)); default: Debug.Assert(false, "Invalid TYMED value"); return(null); } } else { return(null); } }
/// <summary> /// Helper function to populate the contents of a FORMATETC structure /// using the passed clipboard format and type(s). /// </summary> /// <param name="clipFormat">Name of clipboard format requested</param> /// <param name="types">type(s) requested</param> /// <param name="formatEtc">FORMATETC structure to be populated</param> public static void PopulateFORMATETC( string clipFormat, TYMED types, ref FORMATETC formatEtc) { OleDataObjectHelper.PopulateFORMATETC(-1, clipFormat, types, ref formatEtc); }
public bool GetDataPresent(Type format) { Validate(); return(OleDataObjectHelper.GetDataPresentSafe(m_dataObject, format)); }
private static bool HtmlDocumentClassFormatPresent(IDataObject iDataObject) { return(OleDataObjectHelper.GetDataPresentSafe(iDataObject, typeof(HTMLDocumentClass))); }