DropEffects IDropTarget.DragOver(HtmlMouseEvent e) { base.DragOver(e); if (Feedback == FeedbackMode.None) { return(DropEffects.None); } object node = HitNode; if (!Observable.Equals(this.node, node)) { this.node = node; dropEffects = DropEffects.None; if (listItems != null) { ListNode list = node as ListNode; if (list != null) { dropEffects = ListItemsDropUtility.DropEffects(listItems, list.RootFolder); } else { FolderNode folder = node as FolderNode; if (folder != null) { dropEffects = ListItemsDropUtility.DropEffects(listItems, folder); } } } } return(dropEffects & DropEffects.Move); }
void IDropTarget.Drop(HtmlMouseEvent e, DropEffects dropEffect) { try { base.Drop(e); ListItemsDropUtility.Drop(source, targetFolder != null ? targetFolder : itemsPane.Data.FolderItems.ParentFolder); } catch (Exception ex) { LazyWindow.ShowError(ex); } }
void IDropTarget.Drop(HtmlMouseEvent e, DropEffects dropEffect) { TreeViewHit hit = base.Drop(e); if (Feedback != FeedbackMode.None) { try { object node = hit.Nodes.List[hit.Index]; ListNode list = node as ListNode; ListItemsDropUtility.Drop(listItems, list != null ? list.RootFolder : node as Folder); } catch (Exception ex) { LazyWindow.ShowError(ex); } } }
void IDropTarget.Drop(HtmlMouseEvent e, DropEffects dropEffect) { RootNodes rootNodes = (RootNodes)treeView.NodeSource; RootNode rootNode = webNode.RootNode; long index = hit != null ? hit.Index : -1; if (index >= 0 && 2 * (clientY - hit.Rect.Top) >= hit.Rect.Height) { index++; } if (dropEffect == DropEffects.Move) { int pos = 0; while (rootNodes[pos] != rootNode) { pos++; } rootNodes.RemoveRootNode(pos); if (index > pos) { index--; } } else { rootNode = new RootNode() { Url = webNode.Url, Title = webNode.Title, IsSite = rootNode != null && rootNode.IsSite, RootNodes = rootNodes }; } if (index >= 0) { rootNodes.InsertRootNode(index, rootNode); } else { rootNodes.Configuration.Roots.Add(rootNode); } }
internal ListItemsDragSource(IList <ListItem> listItems) { this.listItems = listItems; dropEffects = DropEffects.Copy | DropEffects.Link; int i = 0; for (; i < listItems.Count; i++) { ListItem listItem = listItems[i]; if ((listItem.EffectiveBasePermissions & BasePermissions.DeleteListItems) != BasePermissions.DeleteListItems || (listItem.EffectiveBasePermissions & BasePermissions.EditListItems) != BasePermissions.EditListItems) { break; } } if (i == listItems.Count) { dropEffects |= DropEffects.Move; } }
/// <summary> /// Called as soon as the mouse drags an item over a new hierarchy or hierarchy window /// </summary> /// <param name="dataObject">reference to interface IDataObject of the item being dragged</param> /// <param name="keyState">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="effect">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 dataObject, uint keyState, uint itemId, ref DropEffects effect) { effect = DropEffects.None; if(this.SourceDraggedOrCutOrCopied) { return VSConstants.S_OK; } this._dropDataType = QueryDropDataType(dataObject); if(this._dropDataType != DropDataType.None) { effect = this.QueryDropEffect(this._dropDataType, keyState); } return VSConstants.S_OK; }
internal ItemsOverviewDropTarget(ItemsPane itemsPane, IList <ListItem> source) : base(itemsPane.Overview) { this.itemsPane = itemsPane; this.source = source; dropEffects = ListItemsDropUtility.DropEffects(source, itemsPane.Data.FolderItems.ParentFolder); }
/// <summary> /// Called after your cut/copied items has been pasted /// </summary> ///<param name="wasCut">If true, then the IDataObject has been successfully pasted into a target hierarchy. /// If false, then the cut or copy operation was cancelled.</param> /// <param name="dropEffect">Visual effects associated with the drag and drop operation, such as cursors, bitmaps, and so on. /// These should be the same visual effects used in OnDropNotify</param> /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns> public virtual int OnPaste(bool wasCut, DropEffects dropEffect) { if(!this.SourceDraggedOrCutOrCopied) { return VSConstants.S_FALSE; } if(dropEffect == DropEffects.None) { return OnClear(wasCut); } this.CleanupSelectionDataObject(false, wasCut, dropEffect == DropEffects.Move); this.SourceDraggedOrCutOrCopied = false; return VSConstants.S_OK; }
/// <summary> /// Notifies clients that the dragged item was dropped. /// </summary> /// <param name="dropped">If true, then the dragged item was dropped on the target. If false, then the drop did not occur.</param> /// <param name="effect">Visual effects associated with the drag-and-drop operation, such as cursors, bitmaps, and so on. /// The value of dwEffects passed to the source object via OnDropNotify method is the value of pdwEffects returned by Drop method.</param> /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns> public override int OnDropNotify(bool dropped, DropEffects effect) { if(!this.SourceDraggedOrCutOrCopied) { return VSConstants.S_FALSE; } this.CleanupSelectionDataObject(dropped, false, effect == DropEffects.Move); this.SourceDraggedOrCutOrCopied = false; return VSConstants.S_OK; }
/// <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="dataObject">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="effect">Current state of the keyboard and the mouse modifier keys.</param> /// <param name="cancelDrop">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 dataObject, DropEffects effect, out bool cancelDrop) { // If there is nothing to be dropped just return that drop should be cancelled. if(this.ItemsDraggedOrCutOrCopied == null) { cancelDrop = true; return VSConstants.S_OK; } cancelDrop = false; bool dirty = false; foreach(HierarchyNode node in this.ItemsDraggedOrCutOrCopied) { bool isDirty, isOpen, isOpenedByUs; uint docCookie; IVsPersistDocData ppIVsPersistDocData; DocumentManager 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 string message = SR.GetString(SR.SaveModifiedDocuments, CultureInfo.CurrentUICulture); string title = string.Empty; OLEMSGICON icon = OLEMSGICON.OLEMSGICON_WARNING; OLEMSGBUTTON buttons = OLEMSGBUTTON.OLEMSGBUTTON_YESNOCANCEL; OLEMSGDEFBUTTON defaultButton = OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST; int result = VsShellUtilities.ShowMessageBox(Site, title, message, icon, buttons, defaultButton); switch(result) { case DialogResult.Yes: break; case DialogResult.No: return VSConstants.S_OK; case DialogResult.Cancel: goto default; default: cancelDrop = true; return VSConstants.S_OK; } // Save all dirty documents foreach(HierarchyNode node in this.ItemsDraggedOrCutOrCopied) { DocumentManager manager = node.GetDocumentManager(); if(manager != null) { manager.Save(true); } } return VSConstants.S_OK; }
/// <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 DropEffects pdwEffect) { DropDataType dropDataType = DropDataType.None; if (pDataObject == null) { return(VSConstants.E_INVALIDARG); } pdwEffect = DropEffects.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 = DropEffects.Copy; return((dropDataType != DropDataType.Shell) ? VSConstants.E_FAIL : VSConstants.S_OK); }
public Task <IEnumerable <ICopyPasteItem> > ProcessDataObjectAsync(object dataObject, IProjectTree dropTarget, IProjectTreeProvider currentProvider, DropEffects effect) { _dropTarget = dropTarget; return(PasteProcessor.ProcessDataObjectAsync(dataObject, dropTarget, currentProvider, effect)); }
public bool PromptForAnyOverwrites(IEnumerable <ICopyPasteItem> items, ref DropEffects effect) { return(PasteHandler.PromptForAnyOverwrites(items, ref effect)); }
public async Task <PasteItemsResult> PasteItemsAsync(IEnumerable <ICopyPasteItem> items, DropEffects effect) { Assumes.NotNull(_dropTarget); ImmutableHashSet <string> previousIncludes = await OrderingHelper.GetAllEvaluatedIncludes(_configuredProject, _accessor); PasteItemsResult result = await PasteHandler.PasteItemsAsync(items, effect); await OrderingHelper.Move(_configuredProject, _accessor, previousIncludes, _dropTarget !, OrderingMoveAction.MoveToTop); return(result); }
void IDragSource.Complete(DropEffects dropEffects) { }
/// <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 DropEffects pdwEffect) { DropDataType dropDataType = DropDataType.None; if(pDataObject == null) return VSConstants.E_INVALIDARG; pdwEffect = DropEffects.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 = DropEffects.Copy; return (dropDataType != DropDataType.Shell) ? VSConstants.E_FAIL : VSConstants.S_OK; }
async Task <IEnumerable <ICopyPasteItem> > IPasteDataObjectProcessor.ProcessDataObjectAsync(object dataObject, IProjectTree dropTarget, IProjectTreeProvider currentProvider, DropEffects effect) { var pasteItems = await _underlyingProcessor.ProcessDataObjectAsync(dataObject, dropTarget, currentProvider, effect); // For some reason, the default system paste processor (Microsoft.VisualStudio.ProjectSystem.VS.Implementation.Package.WindowsPasteProcessor) // completely ignores DropEffects.Link, so we set IsLinked and LinkPath manually. if (effect == DropEffects.Link) { foreach (var item in pasteItems) { var sourceProp = item.GetType().GetProperty("Source"); var isLinkedProp = item.GetType().GetProperty("IsLinked"); var linkPathProp = item.GetType().GetProperty("LinkPath"); if (sourceProp != null && isLinkedProp != null && linkPathProp != null) { var sourcePath = (string)sourceProp.GetValue(item); var linkName = Path.GetFileName(sourcePath); isLinkedProp.SetValue(item, true); linkPathProp.SetValue(item, linkName); } } } return(pasteItems); }
public virtual void OnDrop() { DropEffects.Run(Carrier, Context); }
public async Task <PasteItemsResult> PasteItemsAsync(IEnumerable <ICopyPasteItem> items, DropEffects effect) { Assumes.NotNull(_dropTarget); // ConfigureAwait is true because we need to come back for PasteItemsAsync to work. If not, PasteItemsAsync will throw. ImmutableHashSet <string> previousIncludes = await OrderingHelper.GetAllEvaluatedIncludes(_configuredProject, _accessor).ConfigureAwait(true); PasteItemsResult result = await PasteHandler.PasteItemsAsync(items, effect).ConfigureAwait(false); await OrderingHelper.Move(_configuredProject, _accessor, previousIncludes, _dropTarget, OrderingMoveAction.MoveToTop).ConfigureAwait(false); return(result); }
/// <summary> /// Called when one or more items are dragged over the target hierarchy or hierarchy window. /// </summary> /// <param name="keyState">Current state of the keyboard keys and the mouse modifier buttons. 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="effect"> On entry, reference to the value of the pdwEffect parameter of the IVsHierarchy object, identifying all effects that the hierarchy supports. /// On return, the pdwEffect parameter must contain one of the effect flags that indicate the result of the drop operation. For a list of pwdEffects values, see <seealso cref="DragEnter"/></param> /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns> public override int DragOver(uint keyState, uint itemId, ref DropEffects effect) { effect = (uint)DropEffects.None; // Dragging items to a project that is being debugged is not supported // (see VSWhidbey 144785) DBGMODE dbgMode = VsShellUtilities.GetDebugMode(this.Site) & ~DBGMODE.DBGMODE_EncMask; if(dbgMode == DBGMODE.DBGMODE_Run || dbgMode == DBGMODE.DBGMODE_Break) { return VSConstants.S_OK; } if(this.isClosed || this._site == null) { return VSConstants.E_UNEXPECTED; } // We should also analyze if the node being dragged over can accept the drop. if(!this.CanTargetNodeAcceptDrop(itemId)) { return VSConstants.E_NOTIMPL; } if(this._dropDataType != DropDataType.None) { effect = this.QueryDropEffect(this._dropDataType, keyState); } return VSConstants.S_OK; }
public Task <IEnumerable <string> > ValidateItemListAsync(IEnumerable <ICopyPasteItem> items, DropEffects effect) { return(PasteHandler.ValidateItemListAsync(items, effect)); }
/// <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="dataObject">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="keyState">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="effect">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 dataObject, uint keyState, uint itemId, ref DropEffects effect) { if(dataObject == null) { return VSConstants.E_INVALIDARG; } effect = DropEffects.None; // Get the node that is being dragged over and ask it which node should handle this call HierarchyNode 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 { DropDataType dropDataType = DropDataType.None; dropDataType = ProcessSelectionDataObject(dataObject, targetNode); effect = this.QueryDropEffect(dropDataType, keyState); // 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(System.IO.FileNotFoundException e) { Trace.WriteLine("Exception : " + e.Message); if(!Utilities.IsInAutomationFunction(this.Site)) { string message = e.Message; string title = string.Empty; OLEMSGICON icon = OLEMSGICON.OLEMSGICON_CRITICAL; OLEMSGBUTTON buttons = OLEMSGBUTTON.OLEMSGBUTTON_OK; OLEMSGDEFBUTTON defaultButton = OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST; VsShellUtilities.ShowMessageBox(this.Site, title, message, icon, buttons, defaultButton); } returnValue = VSConstants.E_FAIL; } return returnValue; }
public void FilterItemList(IEnumerable <ICopyPasteItem> items, DropEffects effect) { PasteHandler.FilterItemList(items, effect); }
/// <summary> /// Returns information about one or more of the items being dragged /// </summary> /// <param name="effects">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="dataObject">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="dropSource">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 DropEffects effects, out IOleDataObject dataObject, out IDropSource dropSource) { //init out params effects = (uint)DropEffects.None; dataObject = null; dropSource = null; IOleDataObject selectionDataObject = PackageSelectionDataObject(false); if(selectionDataObject == null) { return VSConstants.E_NOTIMPL; } this.SourceDraggedOrCutOrCopied = true; effects = DropEffects.Move | DropEffects.Copy; dataObject = selectionDataObject; return VSConstants.S_OK; }