/// <include file='doc\OleDataObject.uex' path='docs/doc[@for=OleDataObject.OleDataObject1]/*' /> public OleDataObject(IDataObject winData) : base(winData) { this.oleData = winData as IOleDataObject; if (null == this.oleData) oleData = (IOleDataObject)(new Ole2BclDataObject(this as IComDataObject)); }
/// <include file='doc\OleDataObject.uex' path='docs/doc[@for=OleDataObject.OleDataObject2]/*' /> public OleDataObject(IComDataObject comData) : base(comData) { oleData = comData as IOleDataObject; if (null == oleData) this.oleData = (IOleDataObject)(new Ole2BclDataObject(comData)); }
/// <summary> /// This is overridden to handle drop operations correctly in a help file builder project /// </summary> /// <inheritdoc /> public override int Drop(IOleDataObject pDataObject, uint grfKeyState, uint itemid, ref uint pdwEffect) { DropDataType dropDataType = DropDataType.None; if (pDataObject == null) { return(VSConstants.E_INVALIDARG); } pdwEffect = (uint)DropEffect.None; // If the source is within the project, let the base class handle it if (this.SourceDraggedOrCutOrCopied) { return(base.Drop(pDataObject, grfKeyState, itemid, ref pdwEffect)); } // Get the node that is being dragged over and ask it which node should handle this call HierarchyNode targetNode = NodeFromItemId(itemid); if (targetNode == null) { return(VSConstants.S_FALSE); } targetNode = targetNode.GetDragTargetHandlerNode(); dropDataType = this.HandleSelectionDataObject(pDataObject, targetNode); // Since we can get a mix of files that may not necessarily be moved into the project (i.e. // documentation sources and references), we'll always act as if they were copied. pdwEffect = (uint)DropEffect.Copy; return((dropDataType != DropDataType.Shell) ? VSConstants.E_FAIL : VSConstants.S_OK); }
/// <summary> /// 检查工具箱栏目是否存在. /// </summary> bool VerifyToolboxItemExist() { LogEntry(__ACTIVITYLOG_ENTRYTYPE.ALE_INFORMATION, string.Format("Entering VerifyToolboxItemExist for: {0}", this.ToString())); bool exist = false; IEnumToolboxItems items; uint num; ErrorHandler.ThrowOnFailure(vsToolbox2.EnumItems(toolboxTabString, out items)); var rgelt = new Microsoft.VisualStudio.OLE.Interop.IDataObject[1]; for (int i = items.Next(1, rgelt, out num); (ErrorHandler.Succeeded(i) && (num > 0)) && (rgelt[0] != null); i = items.Next(1, rgelt, out num)) { string displayName; var hr = (vsToolbox2 as IVsToolbox3).GetItemDisplayName(rgelt[0], out displayName); ErrorHandler.ThrowOnFailure(hr); if (displayName.Equals(toolboxItemString, StringComparison.OrdinalIgnoreCase)) { exist = true; break; } } LogEntry(__ACTIVITYLOG_ENTRYTYPE.ALE_INFORMATION, string.Format("VerifyToolboxItemExist {0}: {1}", toolboxItemString, exist)); return(exist); }
public static string GetSourceProjectPath(Microsoft.VisualStudio.OLE.Interop.IDataObject dataObject) { string projectPath = null; FORMATETC fmtetc = CreateFormatEtc(CF_VSPROJECTCLIPDESCRIPTOR); if (QueryGetData(dataObject, ref fmtetc) == VSConstants.S_OK) { STGMEDIUM stgmedium = DragDropHelper.GetData(dataObject, ref fmtetc); if (stgmedium.tymed == (uint)TYMED.TYMED_HGLOBAL) { // We are releasing the cloned hglobal here. IntPtr dropInfoHandle = stgmedium.unionmember; if (dropInfoHandle != IntPtr.Zero) { try { string path = GetData(dropInfoHandle); // Clone the path that we can release our memory. if (!String.IsNullOrEmpty(path)) { projectPath = String.Copy(path); } } finally { Marshal.FreeHGlobal(dropInfoHandle); } } } } return(projectPath); }
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]); }
/// <include file='doc\OleDataObject.uex' path='docs/doc[@for=OleDataObject.OleDataObject1]/*' /> public OleDataObject(IDataObject winData) : base(winData) { this.oleData = winData as IOleDataObject; if (null == this.oleData) { oleData = (IOleDataObject)(new Ole2BclDataObject(this as IComDataObject)); } }
/// <include file='doc\OleDataObject.uex' path='docs/doc[@for=OleDataObject.OleDataObject2]/*' /> public OleDataObject(IComDataObject comData) : base(comData) { oleData = comData as IOleDataObject; if (null == oleData) { this.oleData = (IOleDataObject)(new Ole2BclDataObject(comData)); } }
public void DragLeave() { if (m_CurrentObject != null) { m_CurrentObject = null; } else if (m_DefaultDropTarget != null) { m_DefaultDropTarget.DragLeave(); } }
public static int QueryGetData(Microsoft.VisualStudio.OLE.Interop.IDataObject pDataObject, ref FORMATETC fmtetc) { FORMATETC[] af = new FORMATETC[1]; af[0] = fmtetc; int result = pDataObject.QueryGetData(af); if (result == VSConstants.S_OK) { fmtetc = af[0]; return(VSConstants.S_OK); } return(result); }
public void DragEnter(IOleDataObject pDataObj, uint grfKeyState, IOlePoint pt, ref uint pdwEffect) { if ((OutlookDrop != null) && OutlookUtil.IsOutlookItem(pDataObj)) { m_CurrentObject = pDataObj; pdwEffect = DragDropUtil.DRAGDROP_LINK; } else if (m_DefaultDropTarget != null) { m_DefaultDropTarget.DragEnter(pDataObj, grfKeyState, pt, pdwEffect); if (pdwEffect != DragDropUtil.DRAGDROP_NONE) { pdwEffect = DragDropUtil.DRAGDROP_LINK; } } }
int IVsToolboxUser.ItemPicked(Microsoft.VisualStudio.OLE.Interop.IDataObject pDO) { // Redirect toolbox queries to supporting tool windows if the document is not the // active selection container. object selectionContainer = MonitorSelection.CurrentSelectionContainer; IVsToolboxUser redirectUser; IORMDesignerView designerView; if (selectionContainer != this && null != (redirectUser = selectionContainer as IVsToolboxUser) && null != (designerView = selectionContainer as IORMDesignerView) && null != designerView.CurrentDiagram) { return(redirectUser.ItemPicked(pDO)); } return(ItemPicked(pDO)); }
/// <summary> /// Retrieves data from a VS format. /// </summary> public static List <string> GetDroppedFiles(ushort format, Microsoft.VisualStudio.OLE.Interop.IDataObject dataObject, out DropDataType ddt) { ddt = DropDataType.None; List <string> droppedFiles = new List <string>(); // try HDROP FORMATETC fmtetc = CreateFormatEtc(format); if (QueryGetData(dataObject, ref fmtetc) == VSConstants.S_OK) { STGMEDIUM stgmedium = DragDropHelper.GetData(dataObject, ref fmtetc); if (stgmedium.tymed == (uint)TYMED.TYMED_HGLOBAL) { // We are releasing the cloned hglobal here. IntPtr dropInfoHandle = stgmedium.unionmember; if (dropInfoHandle != IntPtr.Zero) { ddt = DropDataType.Shell; try { uint numFiles = UnsafeNativeMethods.DragQueryFile(dropInfoHandle, 0xFFFFFFFF, null, 0); // We are a directory based project thus a projref string is placed on the clipboard. // We assign the maximum length of a projref string. // The format of a projref is : <Proj Guid>|<project rel path>|<file path> uint lenght = (uint)Guid.Empty.ToString().Length + 2 * NativeMethods.MAX_PATH + 2; char[] moniker = new char[lenght + 1]; for (uint fileIndex = 0; fileIndex < numFiles; fileIndex++) { uint queryFileLength = UnsafeNativeMethods.DragQueryFile(dropInfoHandle, fileIndex, moniker, lenght); string filename = new String(moniker, 0, (int)queryFileLength); droppedFiles.Add(filename); } } finally { Marshal.FreeHGlobal(dropInfoHandle); } } } } return(droppedFiles); }
/// <summary> /// Process dataobject from Drag/Drop/Cut/Copy/Paste operation /// </summary> /// <remarks>The targetNode is set if the method is called from a drop operation, otherwise it is null</remarks> internal DropDataType ProcessSelectionDataObject(IOleDataObject dataObject, HierarchyNode targetNode) { var dropDataType = DropDataType.None; var isWindowsFormat = false; // Try to get it as a directory based project. var filesDropped = DragDropHelper.GetDroppedFiles(DragDropHelper.CF_VSSTGPROJECTITEMS, dataObject, out dropDataType); if (filesDropped.Count == 0) { filesDropped = DragDropHelper.GetDroppedFiles(DragDropHelper.CF_VSREFPROJECTITEMS, dataObject, out dropDataType); } if (filesDropped.Count == 0) { filesDropped = DragDropHelper.GetDroppedFiles(NativeMethods.CF_HDROP, dataObject, out dropDataType); isWindowsFormat = filesDropped.Count > 0; } if (dropDataType != DropDataType.None && filesDropped.Count > 0) { var filesDroppedAsArray = filesDropped.ToArray(); var node = targetNode == null ? this : targetNode; // For directory based projects the content of the clipboard is a double-NULL terminated list of Projref strings. if (isWindowsFormat) { // This is the code path when source is windows explorer var vsaddresults = new VSADDRESULT[1]; vsaddresults[0] = VSADDRESULT.ADDRESULT_Failure; var addResult = AddItem(node.ID, VSADDITEMOPERATION.VSADDITEMOP_OPENFILE, null, (uint) filesDropped.Count, filesDroppedAsArray, IntPtr.Zero, vsaddresults); if (addResult != VSConstants.S_OK && addResult != VSConstants.S_FALSE && addResult != (int) OleConstants.OLECMDERR_E_CANCELED && vsaddresults[0] != VSADDRESULT.ADDRESULT_Success) { ErrorHandler.ThrowOnFailure(addResult); } return dropDataType; } if (AddFilesFromProjectReferences(node, filesDroppedAsArray)) { return dropDataType; } } // If we reached this point then the drop data must be set to None. // Otherwise the OnPaste will be called with a valid DropData and that would actually delete the item. return DropDataType.None; }
/// <summary> /// Get the dropdatatype from the dataobject /// </summary> /// <param name="pDataObject">The dataobject to be analysed for its format</param> /// <returns>dropdatatype or none if dataobject does not contain known format</returns> internal static DropDataType QueryDropDataType(IOleDataObject pDataObject) { if (pDataObject == null) { return DropDataType.None; } // known formats include File Drops (as from WindowsExplorer), // VSProject Reference Items and VSProject Storage Items. var fmt = DragDropHelper.CreateFormatEtc(NativeMethods.CF_HDROP); if (DragDropHelper.QueryGetData(pDataObject, ref fmt) == VSConstants.S_OK) { return DropDataType.Shell; } fmt.cfFormat = DragDropHelper.CF_VSREFPROJECTITEMS; if (DragDropHelper.QueryGetData(pDataObject, ref fmt) == VSConstants.S_OK) { // Data is from a Ref-based project. return DropDataType.VsRef; } fmt.cfFormat = DragDropHelper.CF_VSSTGPROJECTITEMS; if (DragDropHelper.QueryGetData(pDataObject, ref fmt) == VSConstants.S_OK) { return DropDataType.VsStg; } return DropDataType.None; }
/// <summary> /// Allows the drag source to prompt to save unsaved items being dropped. /// Notifies the source hierarchy that information dragged from it is about to be dropped on a target. /// This method is called immediately after the mouse button is released on a drop. /// </summary> /// <param name="o"> /// Reference to the IDataObject interface on the item being dragged. /// This data object contains the data being transferred in the drag-and-drop operation. /// If the drop occurs, then this data object (item) is incorporated into the hierarchy window of the new hierarchy. /// </param> /// <param name="dwEffect">Current state of the keyboard and the mouse modifier keys.</param> /// <param name="fCancelDrop"> /// If true, then the drop is cancelled by the source hierarchy. If false, then the drop can /// continue. /// </param> /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns> public override int OnBeforeDropNotify(IOleDataObject o, uint dwEffect, out int fCancelDrop) { // If there is nothing to be dropped just return that drop should be cancelled. if (ItemsDraggedOrCutOrCopied == null) { fCancelDrop = 1; return VSConstants.S_OK; } fCancelDrop = 0; var dirty = false; foreach (var node in ItemsDraggedOrCutOrCopied) { bool isDirty, isOpen, isOpenedByUs; uint docCookie; IVsPersistDocData ppIVsPersistDocData; var manager = node.GetDocumentManager(); if (manager != null) { manager.GetDocInfo(out isOpen, out isDirty, out isOpenedByUs, out docCookie, out ppIVsPersistDocData); if (isDirty && isOpenedByUs) { dirty = true; break; } } } // if there are no dirty docs we are ok to proceed if (!dirty) { return VSConstants.S_OK; } // Prompt to save if there are dirty docs var message = SR.GetString(SR.SaveModifiedDocuments, CultureInfo.CurrentUICulture); var title = string.Empty; var icon = OLEMSGICON.OLEMSGICON_WARNING; var buttons = OLEMSGBUTTON.OLEMSGBUTTON_YESNOCANCEL; var defaultButton = OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST; var result = VsShellUtilities.ShowMessageBox(Site, title, message, icon, buttons, defaultButton); switch (result) { case NativeMethods.IDYES: break; case NativeMethods.IDNO: return VSConstants.S_OK; case NativeMethods.IDCANCEL: goto default; default: fCancelDrop = 1; return VSConstants.S_OK; } // Save all dirty documents foreach (var node in ItemsDraggedOrCutOrCopied) { var manager = node.GetDocumentManager(); if (manager != null) { manager.Save(true); } } return VSConstants.S_OK; }
/// <summary> /// Called as soon as the mouse drags an item over a new hierarchy or hierarchy window /// </summary> /// <param name="pDataObject">reference to interface IDataObject of the item being dragged</param> /// <param name="grfKeyState"> /// Current state of the keyboard and the mouse modifier keys. See docs for a list of possible /// values /// </param> /// <param name="itemid">Item identifier for the item currently being dragged</param> /// <param name="pdwEffect">On entry, a pointer to the current DropEffect. On return, must contain the new valid DropEffect</param> /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns> public override int DragEnter(IOleDataObject pDataObject, uint grfKeyState, uint itemid, ref uint pdwEffect) { pdwEffect = (uint) DropEffect.None; if (SourceDraggedOrCutOrCopied) { return VSConstants.S_OK; } dropDataType = QueryDropDataType(pDataObject); if (dropDataType != DropDataType.None) { pdwEffect = (uint) QueryDropEffect(dropDataType, grfKeyState); } return VSConstants.S_OK; }
public int GetSelectionDataObject(out Microsoft.VisualStudio.OLE.Interop.IDataObject ppIDataObject) { throw new Exception("The method or operation is not implemented."); }
/// <summary> /// Returns information about one or more of the items being dragged /// </summary> /// <param name="pdwOKEffects"> /// Pointer to a DWORD value describing the effects displayed while the item is being dragged, /// such as cursor icons that change during the drag-and-drop operation. /// For example, if the item is dragged over an invalid target point /// (such as the item's original location), the cursor icon changes to a circle with a line through it. /// Similarly, if the item is dragged over a valid target point, the cursor icon changes to a file or folder. /// </param> /// <param name="ppDataObject"> /// Pointer to the IDataObject interface on the item being dragged. /// This data object contains the data being transferred in the drag-and-drop operation. /// If the drop occurs, then this data object (item) is incorporated into the target hierarchy or hierarchy window. /// </param> /// <param name="ppDropSource">Pointer to the IDropSource interface of the item being dragged.</param> /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns> public override int GetDropInfo(out uint pdwOKEffects, out IOleDataObject ppDataObject, out IDropSource ppDropSource) { //init out params pdwOKEffects = (uint) DropEffect.None; ppDataObject = null; ppDropSource = null; IOleDataObject dataObject = PackageSelectionDataObject(false); if (dataObject == null) { return VSConstants.E_NOTIMPL; } SourceDraggedOrCutOrCopied = true; pdwOKEffects = (uint) (DropEffect.Move | DropEffect.Copy); ppDataObject = dataObject; return VSConstants.S_OK; }
public static extern int OleSetClipboard(Microsoft.VisualStudio.OLE.Interop.IDataObject dataObject);
/*internal, but public for FSharp.Project.dll*/ public static extern int OleGetClipboard(out Microsoft.VisualStudio.OLE.Interop.IDataObject dataObject);
/// <summary> /// Process data object from Drag/Drop/Cut/Copy/Paste operation /// </summary> /// <remarks>The targetNode is set if the method is called from a drop operation, otherwise it /// is null</remarks> private DropDataType HandleSelectionDataObject(IOleDataObject dataObject, HierarchyNode targetNode) { DropDataType dropDataType = DropDataType.None; bool isWindowsFormat = false; if(targetNode == null) targetNode = this; // Try to get it as a directory based project List<string> filesDropped = DragDropHelper.GetDroppedFiles(DragDropHelper.CF_VSSTGPROJECTITEMS, dataObject, out dropDataType); if(filesDropped.Count == 0) filesDropped = DragDropHelper.GetDroppedFiles(DragDropHelper.CF_VSREFPROJECTITEMS, dataObject, out dropDataType); if(filesDropped.Count == 0) { filesDropped = DragDropHelper.GetDroppedFiles(NativeMethods.CF_HDROP, dataObject, out dropDataType); isWindowsFormat = (filesDropped.Count > 0); } // Handle documentation sources and references first. These will be removed from the list before // passing on what's left to add as standard project files. if(isWindowsFormat && filesDropped.Count != 0) { List<string> docSources = filesDropped.Where(f => { string ext = Path.GetExtension(f); return (ext.Equals(".sln", StringComparison.OrdinalIgnoreCase) || ext.EndsWith("proj", StringComparison.OrdinalIgnoreCase)); }).ToList(), refSources = filesDropped.Where(f => { string ext = Path.GetExtension(f); return (ext.Equals(".dll", StringComparison.OrdinalIgnoreCase) || ext.Equals(".exe", StringComparison.OrdinalIgnoreCase) || ext.Equals(".winmd", StringComparison.OrdinalIgnoreCase)); }).ToList(), xmlDocSources = filesDropped.Where(f => { string file = Path.GetFileNameWithoutExtension(f), ext = Path.GetExtension(f); // We only want XML files with a base name that matches an assembly in the list return (ext.Equals(".xml", StringComparison.OrdinalIgnoreCase) && refSources.Any(r => Path.GetFileNameWithoutExtension(r).Equals(file, StringComparison.OrdinalIgnoreCase))); }).ToList(), allDocSources = docSources.Concat(refSources).Concat(xmlDocSources).ToList(); var docSourcesNode = targetNode as DocumentationSourcesContainerNode; // If dropped on the Documentation Sources node, add all documentation sources if(docSourcesNode != null) { foreach(string f in allDocSources) { if(!f.EndsWith(".sln", StringComparison.OrdinalIgnoreCase)) docSourcesNode.AddDocumentationSource(f); else foreach(string project in SandcastleBuilder.Utils.MSBuild.SelectProjectsDlg.SelectSolutionOrProjects(f)) docSourcesNode.AddDocumentationSource(project); } } else { var refsNode = targetNode as SandcastleBuilderReferenceContainerNode; // If dropped on the references node, add all reference files if(refsNode != null) foreach(string f in refSources) { var node = refsNode.AddReferenceFromSelectorData(new VSCOMPONENTSELECTORDATA { type = VSCOMPONENTTYPE.VSCOMPONENTTYPE_File, bstrFile = f }, null); // Clear the Name and AseemblyName metadata and set the HintPath metadata so that it // treats it correctly when the project is reloaded if(node != null) { string hintPath = f; if(Path.IsPathRooted(hintPath)) hintPath = PackageUtilities.GetPathDistance(this.ProjectMgr.BaseURI.Uri, new Uri(hintPath)); node.ItemNode.SetMetadata(ProjectFileConstants.Name, null); node.ItemNode.SetMetadata(ProjectFileConstants.AssemblyName, null); node.ItemNode.SetMetadata(ProjectFileConstants.HintPath, hintPath); } } } // Remove the documentation source and reference files from the list filesDropped = filesDropped.Except(allDocSources).ToList(); } // Handle all other file types if(dropDataType != DropDataType.None && filesDropped.Count > 0) { string[] filesDroppedAsArray = filesDropped.ToArray(); // For directory based projects the content of the clipboard is a double-NULL terminated list of // Projref strings. if(isWindowsFormat) { // This is the code path when source is Windows Explorer VSADDRESULT[] vsaddresults = new VSADDRESULT[1]; vsaddresults[0] = VSADDRESULT.ADDRESULT_Failure; int addResult = this.AddItem(targetNode.ID, VSADDITEMOPERATION.VSADDITEMOP_OPENFILE, null, (uint)filesDropped.Count, filesDroppedAsArray, IntPtr.Zero, vsaddresults); if(addResult != VSConstants.S_OK && addResult != VSConstants.S_FALSE && addResult != (int)OleConstants.OLECMDERR_E_CANCELED && vsaddresults[0] != VSADDRESULT.ADDRESULT_Success) ErrorHandler.ThrowOnFailure(addResult); return dropDataType; } else if(AddFilesFromProjectReferences(targetNode, filesDroppedAsArray)) return dropDataType; } // If we reached this point then the drop data must be set to None. Otherwise the OnPaste will be // called with a valid DropData and that would actually delete the item. return DropDataType.None; }
/// <summary> /// This is overridden to handle drop operations correctly in a help file builder project /// </summary> /// <inheritdoc /> public override int Drop(IOleDataObject pDataObject, uint grfKeyState, uint itemid, ref uint pdwEffect) { DropDataType dropDataType = DropDataType.None; if(pDataObject == null) return VSConstants.E_INVALIDARG; pdwEffect = (uint)DropEffect.None; // If the source is within the project, let the base class handle it if(this.SourceDraggedOrCutOrCopied) return base.Drop(pDataObject, grfKeyState, itemid, ref pdwEffect); // Get the node that is being dragged over and ask it which node should handle this call HierarchyNode targetNode = NodeFromItemId(itemid); if(targetNode == null) return VSConstants.S_FALSE; targetNode = targetNode.GetDragTargetHandlerNode(); dropDataType = this.HandleSelectionDataObject(pDataObject, targetNode); // Since we can get a mix of files that may not necessarily be moved into the project (i.e. // documentation sources and references), we'll always act as if they were copied. pdwEffect = (uint)DropEffect.Copy; return (dropDataType != DropDataType.Shell) ? VSConstants.E_FAIL : VSConstants.S_OK; }
/// <include file='doc\OleDataObject.uex' path='docs/doc[@for=OleDataObject.OleDataObject]/*' /> public OleDataObject() { oleData = (IOleDataObject)(new Ole2BclDataObject(this as IComDataObject)); }
public int FilterDataObject(Microsoft.VisualStudio.OLE.Interop.IDataObject pDataObjIn, out Microsoft.VisualStudio.OLE.Interop.IDataObject ppDataObjOut) { ppDataObjOut = null; return(VSErr.S_OK); }
/// <include file='doc\OleDataObject.uex' path='docs/doc[@for=OleDataObject.OleDataObject3]/*' /> public OleDataObject(IOleDataObject oleData) : base((oleData is IComDataObject) ? (IComDataObject)oleData : (IComDataObject)(new Ole2BclDataObject(oleData))) { this.oleData = oleData; }
/// <include file='doc\OleDataObject.uex' path='docs/doc[@for=OleDataObject.OleDataObject3]/*' /> public OleDataObject(IOleDataObject oleData) : base((oleData is IComDataObject) ? (IComDataObject)oleData : (IComDataObject)(new Ole2BclDataObject(oleData))) { this.oleData = oleData; }
int IVsTextView.GetSelectionDataObject(out Microsoft.VisualStudio.OLE.Interop.IDataObject ppIDataObject) { throw new System.NotImplementedException(); }
/// <summary> /// Process data object from Drag/Drop/Cut/Copy/Paste operation /// </summary> /// <remarks>The targetNode is set if the method is called from a drop operation, otherwise it /// is null</remarks> private DropDataType HandleSelectionDataObject(IOleDataObject dataObject, HierarchyNode targetNode) { DropDataType dropDataType = DropDataType.None; bool isWindowsFormat = false; if (targetNode == null) { targetNode = this; } // Try to get it as a directory based project List <string> filesDropped = DragDropHelper.GetDroppedFiles(DragDropHelper.CF_VSSTGPROJECTITEMS, dataObject, out dropDataType); if (filesDropped.Count == 0) { filesDropped = DragDropHelper.GetDroppedFiles(DragDropHelper.CF_VSREFPROJECTITEMS, dataObject, out dropDataType); } if (filesDropped.Count == 0) { filesDropped = DragDropHelper.GetDroppedFiles(NativeMethods.CF_HDROP, dataObject, out dropDataType); isWindowsFormat = (filesDropped.Count > 0); } // Handle documentation sources and references first. These will be removed from the list before // passing on what's left to add as standard project files. if (isWindowsFormat && filesDropped.Count != 0) { List <string> docSources = filesDropped.Where(f => { string ext = Path.GetExtension(f); return(ext.Equals(".sln", StringComparison.OrdinalIgnoreCase) || ext.EndsWith("proj", StringComparison.OrdinalIgnoreCase)); }).ToList(), refSources = filesDropped.Where(f => { string ext = Path.GetExtension(f); return(ext.Equals(".dll", StringComparison.OrdinalIgnoreCase) || ext.Equals(".exe", StringComparison.OrdinalIgnoreCase) || ext.Equals(".winmd", StringComparison.OrdinalIgnoreCase)); }).ToList(), xmlDocSources = filesDropped.Where(f => { string file = Path.GetFileNameWithoutExtension(f), ext = Path.GetExtension(f); // We only want XML files with a base name that matches an assembly in the list return(ext.Equals(".xml", StringComparison.OrdinalIgnoreCase) && refSources.Any(r => Path.GetFileNameWithoutExtension(r).Equals(file, StringComparison.OrdinalIgnoreCase))); }).ToList(), allDocSources = docSources.Concat(refSources).Concat(xmlDocSources).ToList(); var docSourcesNode = targetNode as DocumentationSourcesContainerNode; // If dropped on the Documentation Sources node, add all documentation sources if (docSourcesNode != null) { foreach (string f in allDocSources) { if (!f.EndsWith(".sln", StringComparison.OrdinalIgnoreCase)) { docSourcesNode.AddDocumentationSource(f); } else { foreach (string project in SandcastleBuilder.Utils.MSBuild.SelectProjectsDlg.SelectSolutionOrProjects(f)) { docSourcesNode.AddDocumentationSource(project); } } } } else { var refsNode = targetNode as SandcastleBuilderReferenceContainerNode; // If dropped on the references node, add all reference files if (refsNode != null) { foreach (string f in refSources) { var node = refsNode.AddReferenceFromSelectorData(new VSCOMPONENTSELECTORDATA { type = VSCOMPONENTTYPE.VSCOMPONENTTYPE_File, bstrFile = f }, null); // Clear the Name and AseemblyName metadata and set the HintPath metadata so that it // treats it correctly when the project is reloaded if (node != null) { string hintPath = f; if (Path.IsPathRooted(hintPath)) { hintPath = PackageUtilities.GetPathDistance(this.ProjectMgr.BaseURI.Uri, new Uri(hintPath)); } node.ItemNode.SetMetadata(ProjectFileConstants.Name, null); node.ItemNode.SetMetadata(ProjectFileConstants.AssemblyName, null); node.ItemNode.SetMetadata(ProjectFileConstants.HintPath, hintPath); } } } } // Remove the documentation source and reference files from the list filesDropped = filesDropped.Except(allDocSources).ToList(); } // Handle all other file types if (dropDataType != DropDataType.None && filesDropped.Count > 0) { string[] filesDroppedAsArray = filesDropped.ToArray(); // For directory based projects the content of the clipboard is a double-NULL terminated list of // Projref strings. if (isWindowsFormat) { // This is the code path when source is Windows Explorer VSADDRESULT[] vsaddresults = new VSADDRESULT[1]; vsaddresults[0] = VSADDRESULT.ADDRESULT_Failure; int addResult = this.AddItem(targetNode.ID, VSADDITEMOPERATION.VSADDITEMOP_OPENFILE, null, (uint)filesDropped.Count, filesDroppedAsArray, IntPtr.Zero, vsaddresults); if (addResult != VSConstants.S_OK && addResult != VSConstants.S_FALSE && addResult != (int)OleConstants.OLECMDERR_E_CANCELED && vsaddresults[0] != VSADDRESULT.ADDRESULT_Success) { ErrorHandler.ThrowOnFailure(addResult); } return(dropDataType); } else if (AddFilesFromProjectReferences(targetNode, filesDroppedAsArray)) { return(dropDataType); } } // If we reached this point then the drop data must be set to None. Otherwise the OnPaste will be // called with a valid DropData and that would actually delete the item. return(DropDataType.None); }
/// <summary> /// Called when one or more items are dropped into the target hierarchy or hierarchy window when the mouse button is /// released. /// </summary> /// <param name="pDataObject"> /// Reference to the IDataObject interface on the item being dragged. This data object contains the data being /// transferred in the drag-and-drop operation. /// If the drop occurs, then this data object (item) is incorporated into the target hierarchy or hierarchy window. /// </param> /// <param name="grfKeyState"> /// Current state of the keyboard and the mouse modifier keys. See /// <seealso cref="IVsHierarchyDropDataTarget" /> /// </param> /// <param name="itemid">Item identifier of the drop data target over which the item is being dragged</param> /// <param name="pdwEffect"> /// Visual effects associated with the drag-and drop-operation, such as a cursor, bitmap, and so on. /// The value of dwEffects passed to the source object via the OnDropNotify method is the value of pdwEffects returned /// by the Drop method /// </param> /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns> public override int Drop(IOleDataObject pDataObject, uint grfKeyState, uint itemid, ref uint pdwEffect) { if (pDataObject == null) { return VSConstants.E_INVALIDARG; } pdwEffect = (uint) DropEffect.None; // Get the node that is being dragged over and ask it which node should handle this call var targetNode = NodeFromItemId(itemid); if (targetNode != null) { targetNode = targetNode.GetDragTargetHandlerNode(); } else { // There is no target node. The drop can not be completed. return VSConstants.S_FALSE; } int returnValue; try { var dropDataType = DropDataType.None; dropDataType = ProcessSelectionDataObject(pDataObject, targetNode); pdwEffect = (uint) QueryDropEffect(dropDataType, grfKeyState); // If it is a drop from windows and we get any kind of error we return S_FALSE and dropeffect none. This // prevents bogus messages from the shell from being displayed returnValue = dropDataType != DropDataType.Shell ? VSConstants.E_FAIL : VSConstants.S_OK; } catch (FileNotFoundException e) { Trace.WriteLine("Exception : " + e.Message); if (!Utilities.IsInAutomationFunction(Site)) { var message = e.Message; var title = string.Empty; var icon = OLEMSGICON.OLEMSGICON_CRITICAL; var buttons = OLEMSGBUTTON.OLEMSGBUTTON_OK; var defaultButton = OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST; VsShellUtilities.ShowMessageBox(Site, title, message, icon, buttons, defaultButton); } returnValue = VSConstants.E_FAIL; } return returnValue; }
internal static extern int OleGetClipboard(out Microsoft.VisualStudio.OLE.Interop.IDataObject dataObject);
public void Drop(IOleDataObject pDataObj, uint grfKeyState, IOlePoint pt, ref uint pdwEffect) { if (m_CurrentObject == pDataObj) { try { var outlook = new Application(); var selection = outlook.ActiveExplorer().Selection; if ((selection != null) && (selection.Count >= 1)) { var title = ""; var id = ""; var item = selection[1]; if (item is MailItem) { title = (item as MailItem).Subject; id = (item as MailItem).EntryID; } else if (item is ContactItem) { title = (item as ContactItem).Subject; id = (item as ContactItem).EntryID; } else if (item is JournalItem) { title = (item as JournalItem).Subject; id = (item as JournalItem).EntryID; } else if (item is TaskItem) { title = (item as TaskItem).Subject; id = (item as TaskItem).EntryID; } else if (item is NoteItem) { title = (item as NoteItem).Subject; id = (item as NoteItem).EntryID; } else if (item is AppointmentItem) { title = (item as AppointmentItem).Subject; id = (item as AppointmentItem).EntryID; } if (!String.IsNullOrEmpty(title) && !String.IsNullOrEmpty(id)) { var url = OutlookUtil.FormatItemAsUrl(id); OutlookDrop(this, title, url); pdwEffect = DragDropUtil.DRAGDROP_LINK; } } } catch (System.Exception /*e*/) { pdwEffect = DragDropUtil.DRAGDROP_NONE; } } else if (m_DefaultDropTarget != null) { m_DefaultDropTarget.Drop(pDataObj, grfKeyState, pt, pdwEffect); if (pdwEffect != DragDropUtil.DRAGDROP_NONE) { pdwEffect = DragDropUtil.DRAGDROP_LINK; } } m_CurrentObject = null; }
/// <summary> /// 检查工具箱栏目是否存在. /// </summary> bool VerifyToolboxItemExist() { LogEntry(__ACTIVITYLOG_ENTRYTYPE.ALE_INFORMATION, string.Format("Entering VerifyToolboxItemExist for: {0}", this.ToString())); bool exist = false; IEnumToolboxItems items; uint num; ErrorHandler.ThrowOnFailure(vsToolbox2.EnumItems(toolboxTabString, out items)); var rgelt = new Microsoft.VisualStudio.OLE.Interop.IDataObject[1]; for (int i = items.Next(1, rgelt, out num); (ErrorHandler.Succeeded(i) && (num > 0)) && (rgelt[0] != null); i = items.Next(1, rgelt, out num)) { string displayName; var hr = (vsToolbox2 as IVsToolbox3).GetItemDisplayName(rgelt[0], out displayName); ErrorHandler.ThrowOnFailure(hr); if (displayName.Equals(toolboxItemString, StringComparison.OrdinalIgnoreCase)) { exist = true; break; } } LogEntry(__ACTIVITYLOG_ENTRYTYPE.ALE_INFORMATION, string.Format("VerifyToolboxItemExist {0}: {1}", toolboxItemString, exist)); return exist; }
/// <include file='doc\OleDataObject.uex' path='docs/doc[@for=OleDataObject.OleDataObject]/*' /> public OleDataObject() { oleData = (IOleDataObject)(new Ole2BclDataObject(this as IComDataObject)); }