public HRESULT QueryContinueDrag(BOOL fEscapePressed, User32.MK grfKeyState)
{
bool escapePressed = fEscapePressed != 0;
DragAction action = DragAction.Continue;
if (escapePressed)
{
action = DragAction.Cancel;
}
else if ((grfKeyState & User32.MK.LBUTTON) == 0 &&
(grfKeyState & User32.MK.RBUTTON) == 0 &&
(grfKeyState & User32.MK.MBUTTON) == 0)
{
action = DragAction.Drop;
}
QueryContinueDragEventArgs qcdevent = new QueryContinueDragEventArgs((int)grfKeyState, escapePressed, action);
_peer.OnQueryContinueDrag(qcdevent);
switch (qcdevent.Action)
{
case DragAction.Drop:
return(HRESULT.DRAGDROP_S_DROP);
case DragAction.Cancel:
return(HRESULT.DRAGDROP_S_CANCEL);
default:
return(HRESULT.S_OK);
}
}
public unsafe HRESULT GetDragDropEffect(BOOL fDrag, User32.MK grfKeyState, Ole32.DROPEFFECT *pdwEffect)
{
if (pdwEffect is null)
{
return(HRESULT.E_POINTER);
}
*pdwEffect = Ole32.DROPEFFECT.NONE;
return(HRESULT.S_OK);
}
public HRESULT QueryAcceptData(IComDataObject lpdataobj, IntPtr lpcfFormat, RECO reco, BOOL fReally, IntPtr hMetaPict)
{
Debug.WriteLineIf(RichTextDbg.TraceVerbose, "IRichEditOleCallback::QueryAcceptData(reco=" + reco + ")");
if (reco == RECO.DROP)
{
if (owner.AllowDrop || owner.EnableAutoDragDrop)
{
MouseButtons b = Control.MouseButtons;
Keys k = Control.ModifierKeys;
User32.MK keyState = 0;
// Due to the order in which we get called, we have to set up the keystate here.
// First GetDragDropEffect is called with grfKeyState == 0, and then
// QueryAcceptData is called. Since this is the time we want to fire
// OnDragEnter, but we have yet to get the keystate, we set it up ourselves.
if ((b & MouseButtons.Left) == MouseButtons.Left)
{
keyState |= User32.MK.LBUTTON;
}
if ((b & MouseButtons.Right) == MouseButtons.Right)
{
keyState |= User32.MK.RBUTTON;
}
if ((b & MouseButtons.Middle) == MouseButtons.Middle)
{
keyState |= User32.MK.MBUTTON;
}
if ((k & Keys.Control) == Keys.Control)
{
keyState |= User32.MK.CONTROL;
}
if ((k & Keys.Shift) == Keys.Shift)
{
keyState |= User32.MK.SHIFT;
}
lastDataObject = new DataObject(lpdataobj);
if (!owner.EnableAutoDragDrop)
{
lastEffect = DragDropEffects.None;
}
var e = new DragEventArgs(lastDataObject,
(int)keyState,
Control.MousePosition.X,
Control.MousePosition.Y,
DragDropEffects.All,
lastEffect);
if (fReally == 0)
{
// we are just querying
// We can get here without GetDragDropEffects actually being called first.
// This happens when you drag/drop between two rtb's. Say you drag from rtb1 to rtb2.
// GetDragDropEffects will first be called for rtb1, then QueryAcceptData for rtb1 just
// like in the local drag case. Then you drag into rtb2. rtb2 will first be called in this method,
// and not GetDragDropEffects. Now lastEffect is initialized to None for rtb2, so we would not allow
// the drag. Thus we need to set the effect here as well.
e.Effect = ((keyState & User32.MK.CONTROL) == User32.MK.CONTROL) ? DragDropEffects.Copy : DragDropEffects.Move;
owner.OnDragEnter(e);
}
else
{
owner.OnDragDrop(e);
lastDataObject = null;
}
lastEffect = e.Effect;
if (e.Effect == DragDropEffects.None)
{
Debug.WriteLineIf(RichTextDbg.TraceVerbose, "\tCancel data");
return(HRESULT.E_FAIL);
}
else
{
Debug.WriteLineIf(RichTextDbg.TraceVerbose, "\tAccept data");
return(HRESULT.S_OK);
}
}
else
{
Debug.WriteLineIf(RichTextDbg.TraceVerbose, "\tCancel data, allowdrop == false");
lastDataObject = null;
return(HRESULT.E_FAIL);
}
}
else
{
return(HRESULT.E_NOTIMPL);
}
}
public unsafe HRESULT GetDragDropEffect(BOOL fDrag, User32.MK grfKeyState, Ole32.DROPEFFECT *pdwEffect)
{
if (pdwEffect is null)
{
return(HRESULT.E_POINTER);
}
Debug.WriteLineIf(RichTextDbg.TraceVerbose, "IRichEditOleCallback::GetDragDropEffect");
if (owner.AllowDrop || owner.EnableAutoDragDrop)
{
if (fDrag.IsTrue() && grfKeyState == (User32.MK) 0)
{
// This is the very first call we receive in a Drag-Drop operation,
// so we will let the control know what we support.
// Note that we haven't gotten any data yet, so we will let QueryAcceptData
// do the OnDragEnter. Note too, that grfKeyState does not yet reflect the
// current keystate
if (owner.EnableAutoDragDrop)
{
lastEffect = (DragDropEffects.All | DragDropEffects.None);
}
else
{
lastEffect = DragDropEffects.None;
}
}
else
{
// We are either dragging over or dropping
// The below is the complete reverse of what the docs on MSDN suggest,
// but if we follow the docs, we would be firing OnDragDrop all the
// time instead of OnDragOver (see
// drag - fDrag = false, grfKeyState != 0
// drop - fDrag = false, grfKeyState = 0
// We only care about the drag.
//
// When we drop, lastEffect will have the right state
if (fDrag.IsFalse() && lastDataObject is not null && grfKeyState != (User32.MK) 0)
{
DragEventArgs e = new DragEventArgs(lastDataObject,
(int)grfKeyState,
Control.MousePosition.X,
Control.MousePosition.Y,
DragDropEffects.All,
lastEffect);
// Now tell which of the allowable effects we want to use, but only if we are not already none
if (lastEffect != DragDropEffects.None)
{
e.Effect = ((grfKeyState & User32.MK.CONTROL) == User32.MK.CONTROL) ? DragDropEffects.Copy : DragDropEffects.Move;
}
owner.OnDragOver(e);
lastEffect = e.Effect;
}
}
*pdwEffect = (Ole32.DROPEFFECT)lastEffect;
}
else
{
*pdwEffect = Ole32.DROPEFFECT.NONE;
}
return(HRESULT.S_OK);
}
private static HRESULT QueryContinueDrag(IntPtr thisPtr, BOOL fEscapePressed, User32.MK grfKeyState)
{
try
{
var instance = ComInterfaceDispatch.GetInstance <Ole32.IDropSource>((ComInterfaceDispatch *)thisPtr);
return(instance.QueryContinueDrag(fEscapePressed, grfKeyState));
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return((HRESULT)ex.HResult);
}
}
private static HRESULT QueryContinueDrag(IntPtr thisPtr, BOOL fEscapePressed, User32.MK grfKeyState)
{
var inst = ComInterfaceDispatch.GetInstance <Ole32.IDropSource>((ComInterfaceDispatch *)thisPtr);
return(inst.QueryContinueDrag(fEscapePressed, grfKeyState));
}
