private void StartDragInProcAdorner(MouseEventArgs e)
{
// Let's define our DragScope .. In this case it is every thing inside our main window ..
DragScope = Program.MainWindow.Content as FrameworkElement;
Debug.Assert(DragScope != null);
// We enable Drag & Drop in our scope ... We are not implementing Drop, so it is OK, but this allows us to get DragOver
bool previousDrop = DragScope != null && DragScope.AllowDrop;
if (DragScope != null)
{
DragScope.AllowDrop = true;
}
// Let's wire our usual events..
// GiveFeedback just tells it to use no standard cursors..
GiveFeedbackEventHandler feedbackhandler = DragSourceGiveFeedback;
GiveFeedback += feedbackhandler;
// The DragOver event ...
DragEventHandler draghandler = Window1DragOver;
DragScope.PreviewDragOver += draghandler;
// Drag Leave is optional, but write up explains why I like it ..
DragEventHandler dragleavehandler = DragScopeDragLeave;
DragScope.DragLeave += dragleavehandler;
// QueryContinue Drag goes with drag leave...
QueryContinueDragEventHandler queryhandler = DragScopeQueryContinueDrag;
DragScope.QueryContinueDrag += queryhandler;
//Here we create our adorner..
_adorner = new DragAdorner(DragScope, this, true, 0.5);
_layer = AdornerLayer.GetAdornerLayer(DragScope);
_layer.Add(_adorner);
IsDragging = true;
_dragHasLeftScope = false;
//Finally lets drag drop
//var data = new DataObject(DataFormats.Text, "abcd");
//DragDropEffects de = DragDrop.DoDragDrop(this, data, DragDropEffects.Move);
// Clean up our mess :)
DragScope.AllowDrop = previousDrop;
AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
_adorner = null;
GiveFeedback -= feedbackhandler;
DragScope.DragLeave -= dragleavehandler;
DragScope.QueryContinueDrag -= queryhandler;
DragScope.PreviewDragOver -= draghandler;
IsDragging = false;
}
public void WebBrowserBase_GiveFeedback_AddRemove_ThrowsNotSupportedException()
{
using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
GiveFeedbackEventHandler handler = (sender, e) => { };
Assert.Throws <NotSupportedException>(() => control.GiveFeedback += handler);
control.GiveFeedback -= handler;
}
public void AxHost_GiveFeedback_AddRemove_ThrowsNotSupportedException()
{
var control = new SubAxHost("00000000-0000-0000-0000-000000000000");
GiveFeedbackEventHandler handler = (sender, e) => { };
Assert.Throws <NotSupportedException>(() => control.GiveFeedback += handler);
control.GiveFeedback -= handler;
}
internal static new void InvokeHandler(Delegate handler, IntPtr sender, IntPtr args)
{
GiveFeedbackEventHandler handler_ = (GiveFeedbackEventHandler)handler;
if (handler_ != null)
{
handler_(Extend.GetProxy(sender, false), new GiveFeedbackEventArgs(args, false));
}
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// givefeedbackeventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this GiveFeedbackEventHandler givefeedbackeventhandler, Object sender, GiveFeedbackEventArgs e, AsyncCallback callback)
{
if (givefeedbackeventhandler == null)
{
throw new ArgumentNullException("givefeedbackeventhandler");
}
return(givefeedbackeventhandler.BeginInvoke(sender, e, callback, null));
}
private void StartDragCustomCursor(object sender, MouseEventArgs e)
{
Panel panel = (Panel)sender;
object dataContext = panel.DataContext;
GiveFeedbackEventHandler handler = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
((FrameworkElement)sender).GiveFeedback += handler;
IsDragging = true;
DataObject data = new DataObject(dataContext.GetType(), dataContext);
DragDropEffects de = DragDrop.DoDragDrop(((FrameworkElement)sender), data, DragDropEffects.Move);
((FrameworkElement)sender).GiveFeedback -= handler;
IsDragging = false;
}
private void Initialize(IconPanel parent, Image imgPanel, Image imgDrag, int index, Object IconData, EventHandler onClickEvent, DoubleClickIconEvent onDoubleClickEvent)
{
this.index = index;
this.iconPanel = parent;
this.m_oIconData = IconData;
m_imgDrag = imgDrag;
if (IconData == null)
{
throw new Exception("IconData is not set for this panel icon.");
}
Image = imgPanel;
Visible = true;
Location = new Point(iconPanel.outlookBar.Size.Width / 2 - imgPanel.Size.Width / 2,
iconPanel.PanelMargin + index * iconPanel.IconSpacing);
Size = imgPanel.Size;
if (onClickEvent != null)
{
Click += onClickEvent;
}
if (onDoubleClickEvent != null)
{
DoubleClickIcon += onDoubleClickEvent;
}
Tag = this;
MouseEnter += new EventHandler(OnMouseEnter);
MouseLeave += new EventHandler(OnMouseLeave);
MouseMove += new MouseEventHandler(OnMouseMove);
MouseDown += new MouseEventHandler(OnMouseDown);
GiveFeedback += new GiveFeedbackEventHandler(OnGiveFeedback);
m_imageDrag = new ImageListDrag();
m_imageList = new ImageList();
m_imageList.ImageSize = new Size(imgDrag.Width, imgDrag.Height);
m_imageDrag.Imagelist = m_imageList;
m_imageList.Images.Add(imgDrag, System.Drawing.Color.Transparent);
m_bDraggingIcon = false;
bckgColor = iconPanel.BackColor;
//mouseEnter=false;
AllowDrop = true;
}
/// <summary>
/// Removes a handler from the attached GiveFeedback event.
/// </summary>
/// <param name="element">The DependencyObject to attach an event handler for.</param>
/// <param name="handler">The event handler.</param>
internal static void RemoveGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
ExtendedRoutedEventHandlerCollection <GiveFeedbackEventHandler, GiveFeedbackEventArgs> handlers = element.GetGiveFeedbackHandlers();
if (handlers != null)
{
handlers.Remove(handler);
}
}
public BetterTreeView()
{
// Setup internal event handlers
AllowDrop = true;
BeforeExpand += new TreeViewCancelEventHandler(BetterTreeView_BeforeExpand);
BeforeCollapse += new TreeViewCancelEventHandler(BetterTreeView_BeforeCollapse);
DrawNode += new DrawTreeNodeEventHandler(BetterTreeView_DrawNode);
DrawMode = TreeViewDrawMode.OwnerDrawAll;
CheckBoxes = true;
AfterCheck += new TreeViewEventHandler(BetterTreeView_AfterCheck);
ItemDrag += new ItemDragEventHandler(BetterTreeView_ItemDrag);
DragOver += new DragEventHandler(BetterTreeView_DragOver);
DragDrop += new DragEventHandler(BetterTreeView_DragDrop);
DragEnter += new DragEventHandler(BetterTreeView_DragEnter);
DragLeave += new EventHandler(BetterTreeView_DragLeave);
GiveFeedback += new GiveFeedbackEventHandler(BetterTreeView_GiveFeedback);
}
public ResourceTree()
{
SetStyle(ControlStyles.UserMouse, true);
_timer.Interval = 200;
_timer.Tick += new EventHandler(timer_Tick);
AllowDrop = true;
ItemDrag += new ItemDragEventHandler(treeView_ItemDrag);
DragOver += new DragEventHandler(treeView1_DragOver);
DragDrop += new DragEventHandler(treeView1_DragDrop);
DragEnter += new DragEventHandler(treeView1_DragEnter);
DragLeave += new EventHandler(treeView1_DragLeave);
GiveFeedback += new GiveFeedbackEventHandler(treeView1_GiveFeedback);
m_DelegateOpenFile = new DelegateOpenFile(ImportFile);
}
static AttachEventHandlerAction()
{
//
// Initialize event handlers.
//
eventHandlers[typeof(EventHandler)] = new EventHandler(OnGenericEvent);
eventHandlers[typeof(RoutedEventHandler)] = new RoutedEventHandler(OnRoutedEvent);
eventHandlers[typeof(KeyEventHandler)] = new KeyEventHandler(OnKeyEvent);
eventHandlers[typeof(KeyboardFocusChangedEventHandler)] = new KeyboardFocusChangedEventHandler(OnFocusEvent);
eventHandlers[typeof(TextCompositionEventHandler)] = new TextCompositionEventHandler(OnTextCompositionEvent);
eventHandlers[typeof(MouseEventHandler)] = new MouseEventHandler(OnMouseEvent);
eventHandlers[typeof(MouseButtonEventHandler)] = new MouseButtonEventHandler(OnMouseButtonEvent);
eventHandlers[typeof(MouseButtonEventHandler)] = new MouseButtonEventHandler(OnMouseDoubleClickEvent);
eventHandlers[typeof(MouseWheelEventHandler)] = new MouseWheelEventHandler(OnMouseWheelEvent);
eventHandlers[typeof(DragEventHandler)] = new DragEventHandler(OnDragEvent);
eventHandlers[typeof(GiveFeedbackEventHandler)] = new GiveFeedbackEventHandler(OnFeedbackEvent);
eventHandlers[typeof(QueryCursorEventHandler)] = new QueryCursorEventHandler(OnQueryCursorEvent);
eventHandlers[typeof(ExecutedRoutedEventHandler)] = new ExecutedRoutedEventHandler(OnExecutedEvent);
eventHandlers[typeof(CanExecuteRoutedEventHandler)] = new CanExecuteRoutedEventHandler(OnCanExecuteEvent);
eventHandlers[typeof(DependencyPropertyChangedEventHandler)] = new DependencyPropertyChangedEventHandler(OnPropertyChangedEvent);
//
// Initialize routed event static method list.
//
staticMethods = new List <MethodInfo>();
Type[] types = new Type[] { typeof(Mouse), typeof(Keyboard), typeof(CommandManager) };
foreach (Type type in types)
{
MethodInfo[] methodInfos = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
foreach (MethodInfo methodInfo in methodInfos)
{
if (methodInfo.Name.EndsWith("Handler", StringComparison.InvariantCulture) &&
(methodInfo.Name.StartsWith("Add", StringComparison.InvariantCulture) ||
methodInfo.Name.StartsWith("Remove", StringComparison.InvariantCulture)))
{
staticMethods.Add(methodInfo);
}
}
}
}
/// <summary>
/// Adds a handler to the attached GiveFeedback event.
/// </summary>
/// <param name="element">The DependencyObject to attach an event handler for.</param>
/// <param name="handler">The event handler.</param>
/// <param name="handledEventsToo">A value Indicating whether to invoke the
/// handler if the event has been handled.</param>
internal static void AddGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler, bool handledEventsToo)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
ExtendedRoutedEventHandlerCollection <GiveFeedbackEventHandler, GiveFeedbackEventArgs> originalHandlers = element.GetGiveFeedbackHandlers();
ExtendedRoutedEventHandlerCollection <GiveFeedbackEventHandler, GiveFeedbackEventArgs> handlers = originalHandlers ?? new ExtendedRoutedEventHandlerCollection <GiveFeedbackEventHandler, GiveFeedbackEventArgs>((h, a) => h(element, a));
handlers.Add(handler, handledEventsToo);
if (handlers != originalHandlers)
{
element.SetValue(GiveFeedbackHandlerProperty, handlers);
}
}
private void StartDrag(MouseEventArgs e, DragDropSource objectBeenDragged)
{
DestroyDragDropWindow();
this.isDragging = true;
GiveFeedbackEventHandler feedbackHandler = new GiveFeedbackEventHandler(OnDragSourceGiveFeedback);;
this.mainControl.GiveFeedback += feedbackHandler;
QueryContinueDragEventHandler queryContinueHandler = new QueryContinueDragEventHandler(OnDragSourceQueryContinueDrag);
this.mainControl.QueryContinueDrag += queryContinueHandler;
try
{
if (objectBeenDragged.VisualForDraginSource == null)
{
objectBeenDragged.VisualForDraginSource = new Rectangle();
}
CreateDragDropWindow(objectBeenDragged.VisualForDraginSource);
// Initialize the drag & drop operation
DataObject dragData = new DataObject(formatName, objectBeenDragged.DataSource);
DragDrop.DoDragDrop(this.mainControl, dragData, DragDropEffects.Move | DragDropEffects.Copy);
}
catch
{
}
finally
{
this.isDragging = false;
DestroyDragDropWindow();
this.mainControl.GiveFeedback -= feedbackHandler;
this.mainControl.QueryContinueDrag -= queryContinueHandler;
}
}
private void StartDragWindow(MouseEventArgs e)
{
GiveFeedbackEventHandler feedbackhandler = DragSourceGiveFeedback;
GiveFeedback += feedbackhandler;
QueryContinueDragEventHandler queryhandler = DragSourceQueryContinueDrag;
QueryContinueDrag += queryhandler;
IsDragging = true;
CreateDragDropWindow(this);
//DataObject data = new DataObject(System.Windows.DataFormats.Text.ToString(), "abcd");
var data = new DataObject(DataFormats.Text, _mUser.User.Bare);
//DataObject data = new DataObject(this.m_User);
_dragdropWindow.Show();
DragDropEffects de = DragDrop.DoDragDrop(this, data, DragDropEffects.Move);
DestroyDragDropWindow();
IsDragging = false;
GiveFeedback -= feedbackhandler;
QueryContinueDrag -= queryhandler;
}
private void dtGridActors_PreviewMouseMove(object sender, MouseEventArgs e)
{
if (e.LeftButton == MouseButtonState.Pressed)// && !IsDragging)
{
int i = dtGridActors.SelectedIndex;
if (i < 0)
{
return;
}
AtomDTOData currAtomData = (AtomDTOData)dtGridActors.Items[i];
Point position = e.GetPosition(null);
if (Math.Abs(position.X - _startPoint.X) > SystemParameters.MinimumHorizontalDragDistance ||
Math.Abs(position.Y - _startPoint.Y) > SystemParameters.MinimumVerticalDragDistance)
{
_allOpsCursor = null;
GiveFeedbackEventHandler handler = new GiveFeedbackEventHandler(dtGridActors_GiveFeedback);
this.dtGridActors.GiveFeedback += handler;
IsDragging = true;
try
{
DataObject data = new DataObject(typeof(FormationTree), currAtomData.atom);
data.SetText("Actor");
DragDropEffects de = DragDrop.DoDragDrop(dtGridActors, data, DragDropEffects.Move);
}
catch (Exception ex)
{
//this.treeViewForce.GiveFeedback -= handler;
//this.treeViewForce.GiveFeedback += handler;
}
this.dtGridActors.GiveFeedback -= handler;
IsDragging = false;
}
}
}
public void StartDrag(AyDragInfo dragInfo)
{
int itemCount = dragInfo.SourceItems.Cast <object>().Count();
if (itemCount == 1)
{
dragInfo.Data = dragInfo.SourceItems.Cast <object>().First();
}
else if (itemCount > 1)
{
dragInfo.Data = TypeUtilities.CreateDynamicallyTypedList(dragInfo.SourceItems);
}
dragInfo.Effects = (dragInfo.Data != null) ?
DragDropEffects.Copy | DragDropEffects.Move :
DragDropEffects.None;
if (handler22 == null)
{
handler22 = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
}
dragInfo.VisualSource.GiveFeedback += handler22;
}
/// <summary>
/// Adds a handler to the attached GiveFeedback event.
/// </summary>
/// <param name="element">The DependencyObject to attach an event handler for.</param>
/// <param name="handler">The event handler.</param>
internal static void AddGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
AddGiveFeedbackHandler(element, handler, false);
}
/// <summary>
/// Removes a handler for the GiveFeedback attached event
/// </summary>
/// <param name="element">UIElement or ContentElement that listens to this event</param>
/// <param name="handler">Event Handler to be removed</param>
public static void RemoveGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
UIElement.RemoveHandler(element, GiveFeedbackEvent, handler);
}
private void StartDrag(MouseEventArgs mouseEventArgs, TreeView treeView, TreeViewItem item)
{
// dragging actual favorites (or favorite groups)...
var selected = treeView.SelectedItem as TaxonFavoriteViewModel;
if (selected != null) {
string desc = "";
var data = new DataObject("TaxonFavorite", selected);
if (selected.IsGroup) {
desc = String.Format("Favorite Folder: Name={0} [FavoriteID={1}]", selected.TaxaFullName, selected.FavoriteID);
} else {
desc = String.Format("Taxon Favorite: Name={0} [TaxonID={1}, FavoriteID={2}]", selected.TaxaFullName, selected.TaxaID, selected.FavoriteID);
data.SetData(PinnableObject.DRAG_FORMAT_NAME, TaxonExplorer.Owner.CreatePinnableTaxon(selected.TaxaID));
}
data.SetData(DataFormats.Text, desc);
_dropScope = treeView;
_dropScope.AllowDrop = true;
GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DropScope_GiveFeedback);
item.GiveFeedback += feedbackhandler;
var handler = new DragEventHandler((s, e) => {
TreeViewItem destItem = GetHoveredTreeViewItem(e);
e.Effects = DragDropEffects.None;
if (destItem != null) {
destItem.IsSelected = true;
var destModel = destItem.Header as TaxonFavoriteViewModel;
if (destModel != null) {
if (destModel.IsGroup) {
e.Effects = DragDropEffects.Move;
}
} else {
if (destItem.Header is ViewModelPlaceholder) {
e.Effects = DragDropEffects.Move;
}
}
}
e.Handled = true;
});
treeView.PreviewDragEnter += handler;
treeView.PreviewDragOver += handler;
var dropHandler = new DragEventHandler(treeView_Drop);
treeView.Drop += dropHandler;
try {
_IsDragging = true;
DragDrop.DoDragDrop(item, data, DragDropEffects.Copy | DragDropEffects.Move | DragDropEffects.Link);
} finally {
_IsDragging = false;
treeView.PreviewDragEnter -= handler;
treeView.PreviewDragOver -= handler;
treeView.Drop -= dropHandler;
}
} else {
var taxon = treeView.SelectedItem as TaxonViewModel;
if (taxon != null) {
DataObject data = new DataObject("Taxon", taxon);
data.SetData(PinnableObject.DRAG_FORMAT_NAME, TaxonExplorer.Owner.CreatePinnableTaxon(taxon.TaxaID.Value));
data.SetData(DataFormats.Text, taxon.TaxaFullName);
data.SetData(DataFormats.UnicodeText, taxon.TaxaFullName);
data.SetData(DataFormats.StringFormat, taxon.TaxaFullName);
try {
_IsDragging = true;
DragDrop.DoDragDrop(item, data, DragDropEffects.Copy | DragDropEffects.Move | DragDropEffects.Link);
} finally {
_IsDragging = false;
}
}
}
InvalidateVisual();
}
void StartDrag(MouseEventArgs args)
{
if (!_canDrag)
{
sb_Completed(null, null);
return;
}
_canDrag = false;
sb_Completed(null, null);
_data = null;
UIElement dragelement = null;
dragelement = args.Source as UIElement;
/////////////////////////////////////////////////////////////////////// DragData.Data
_data = new DataObject(typeof(UIElement).ToString(), dragelement);
if (dragelement == null || _data == null)
return;
if (dragelement is Visual)
{
DragData.Data = dragelement;
}
else
{
this.IsDragging = false;
return;
}
QueryContinueDragEventHandler queryContinue = null;
GiveFeedbackEventHandler giveFeedback = null;
_effects = GetDragDropEffects();
DragDrop.AddPreviewQueryContinueDragHandler(_dragSource, queryContinue = new QueryContinueDragEventHandler(onQueryContinueDrag));
DragDrop.AddGiveFeedbackHandler(_dragSource, giveFeedback = new GiveFeedbackEventHandler(onGiveFeedback));
IsDragging = true;
bool isReady = CreateDragDropWindow(dragelement);
if (isReady == false)
{
IsDragging = false;
return;
}
_dragdropWindow.Show();
System.Drawing.Rectangle fff = System.Windows.Forms.Screen.GetWorkingArea(new System.Drawing.Point(0, 0));
try
{
_resultEffects = DragDrop.DoDragDrop(_dragSource, _data, _effects);
}
catch { _resultEffects = DragDropEffects.None; }
finally
{
_resultEffects = DragDropEffects.None;
}
DestroyDragDropWindow();
DragDrop.RemovePreviewQueryContinueDragHandler(_dragSource, onQueryContinueDrag);
DragDrop.AddGiveFeedbackHandler(_dragSource, onGiveFeedback);
IsDragging = false;
DragFinished(_resultEffects);
_canDrag = true;
}
private void Initialize(IconPanel parent, Image imgPanel, Image imgDrag, int index, Object IconData, EventHandler onClickEvent, DoubleClickIconEvent onDoubleClickEvent)
{
this.index=index;
this.iconPanel=parent;
this.m_oIconData = IconData;
m_imgDrag = imgDrag;
if(IconData == null)
throw new Exception("IconData is not set for this panel icon.");
Image=imgPanel;
Visible=true;
Location=new Point(iconPanel.outlookBar.Size.Width/2-imgPanel.Size.Width/2,
iconPanel.Margin + index*iconPanel.IconSpacing);
Size=imgPanel.Size;
if(onClickEvent != null)
Click+=onClickEvent;
if(onDoubleClickEvent != null)
DoubleClickIcon+=onDoubleClickEvent;
Tag=this;
MouseEnter+=new EventHandler(OnMouseEnter);
MouseLeave+=new EventHandler(OnMouseLeave);
MouseMove+=new MouseEventHandler(OnMouseMove);
MouseDown+=new MouseEventHandler(OnMouseDown);
GiveFeedback+=new GiveFeedbackEventHandler(OnGiveFeedback);
m_imageDrag = new ImageListDrag();
m_imageList = new ImageList();
m_imageList.ImageSize = new Size(imgDrag.Width, imgDrag.Height);
m_imageDrag.Imagelist = m_imageList;
m_imageList.Images.Add(imgDrag, System.Drawing.Color.Transparent);
m_bDraggingIcon = false;
bckgColor=iconPanel.BackColor;
//mouseEnter=false;
AllowDrop = true;
}
private void StartDrag(MouseEventArgs args)
{
IDataObject data = null;
UIElement dragelement = null;
// ADD THE DATA
if (this.Callback != null)
{
DragDataWrapper dw = new DragDataWrapper();
data = new DataObject(typeof(DragDataWrapper).ToString(), dw);
if ((this.Callback.SupportedActions & DragDropProviderActions.MultiFormatData) != 0)
{
this.Callback.AppendData(ref data, args);
}
if ((this.Callback.SupportedActions & DragDropProviderActions.Data) != 0)
{
dw.Data = this.Callback.GetData();
}
if ((this.Callback.SupportedActions & DragDropProviderActions.Visual) != 0)
{
dragelement = this.Callback.GetVisual(args);
}
else
{
dragelement = args.OriginalSource as UIElement;
}
dw.Source = this.DragSource;
dw.Shim = this.Callback;
Debug.Assert(this.DragScope == null, "The DragDataWrapper is meant for in-proc... Sorry for asserting, just wanted to confirm.. comment out assertion if needed");
}
else
{
dragelement = args.OriginalSource as UIElement;
data = new DataObject(typeof(UIElement).ToString(), dragelement);
}
if (dragelement == null || data == null || dragelement == this.DragSource)
{
return;
}
DragEventHandler dragOver = null;
DragEventHandler dragLeave = null;
QueryContinueDragEventHandler queryContinue = null;
GiveFeedbackEventHandler giveFeedback = null;
DragDropEffects effects = this.GetDragDropEffects();
DragDropEffects resultEffects;
// Inprocess Drag ...
if (this.DragScope != null)
{
bool previousAllowDrop = this.DragScope.AllowDrop;
this.adorner = new DragAdorner(this.DragScope, (UIElement)dragelement, true, this.Opacity);
this.layer = AdornerLayer.GetAdornerLayer(this.DragScope as Visual);
this.layer.Add(this.adorner);
if (this.DragScope != this.DragSource)
{
this.DragScope.AllowDrop = true;
DragDrop.AddPreviewDragOverHandler((DependencyObject)this.DragScope, dragOver = new DragEventHandler(DragScope_DragOver));
DragDrop.AddPreviewDragLeaveHandler(this.DragScope, dragLeave = new DragEventHandler(DragScope_DragLeave));
DragDrop.AddPreviewQueryContinueDragHandler(this.DragSource, queryContinue = new QueryContinueDragEventHandler(OnQueryContinueDrag));
}
try
{
this.IsDragging = true;
this.mouseLeftScope = false;
resultEffects = DragDrop.DoDragDrop(this.DragSource, data, effects);
this.DragFinished(resultEffects);
}
catch
{
Debug.Assert(false);
}
if (this.DragScope != this.DragSource)
{
this.DragScope.AllowDrop = previousAllowDrop;
DragDrop.RemovePreviewDragOverHandler(this.DragScope, dragOver);
DragDrop.RemovePreviewDragLeaveHandler(this.DragScope, dragLeave);
DragDrop.RemovePreviewQueryContinueDragHandler(this.DragSource, queryContinue);
}
}
else
{
DragDrop.AddPreviewQueryContinueDragHandler(this.DragSource, queryContinue = new QueryContinueDragEventHandler(OnQueryContinueDrag));
DragDrop.AddGiveFeedbackHandler(this.DragSource, giveFeedback = new GiveFeedbackEventHandler(OnGiveFeedback));
this.IsDragging = true;
if ((this.Callback.SupportedActions & DragDropProviderActions.Visual) != 0)
{
this.CreateDragDropWindow(dragelement);
this.dragdropWindow.Show();
}
try
{
resultEffects = DragDrop.DoDragDrop(this.DragSource, data, effects);
}
finally
{
}
if ((this.Callback.SupportedActions & DragDropProviderActions.Visual) != 0)
{
this.DestroyDragDropWindow();
}
DragDrop.RemovePreviewQueryContinueDragHandler(this.DragSource, OnQueryContinueDrag);
DragDrop.AddGiveFeedbackHandler(this.DragSource, OnGiveFeedback);
this.IsDragging = false;
this.DragFinished(resultEffects);
}
}
void StartDrag(MouseEventArgs args)
{
IDataObject data = null;
UIElement dragelement = null;
// ADD THE DATA
if (_callback != null)
{
DragDataWrapper dw = new DragDataWrapper();
data = new DataObject(typeof(DragDataWrapper).ToString(), dw);
if ((_callback.SupportedActions & DragDropProviderActions.MultiFormatData) != 0)
_callback.AppendData(ref data, args);
if ((_callback.SupportedActions & DragDropProviderActions.Data) != 0)
dw.Data = _callback.GetData();
if ((_callback.SupportedActions & DragDropProviderActions.Visual) != 0)
dragelement = _callback.GetVisual(args);
else
dragelement = args.OriginalSource as UIElement;
dw.Source = _dragSource;
dw.Shim = _callback;
}
else
{
dragelement = args.OriginalSource as UIElement;
data = new DataObject(typeof(UIElement).ToString(), dragelement);
}
// mwa changed from:
// if (dragelement == null || data == null || dragelement == this._dragSource)
if (dragelement == null || data == null)
return;
DragEventHandler dragOver = null;
DragEventHandler dragLeave = null;
QueryContinueDragEventHandler queryContinue = null;
GiveFeedbackEventHandler giveFeedback = null;
DragDropEffects effects = GetDragDropEffects();
DragDropEffects resultEffects;
// Inprocess Drag ...
if (DragScope != null)
{
bool previousAllowDrop = DragScope.AllowDrop;
_adorner = new DragAdorner(DragScope, (UIElement)dragelement, true, Opacity);
_layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
_layer.Add(_adorner);
if (DragScope != _dragSource)
{
DragScope.AllowDrop = true;
System.Windows.DragDrop.AddPreviewDragOverHandler((DependencyObject)DragScope, dragOver = new DragEventHandler(DragScope_DragOver));
System.Windows.DragDrop.AddPreviewDragLeaveHandler(DragScope, dragLeave = new DragEventHandler(DragScope_DragLeave));
System.Windows.DragDrop.AddPreviewQueryContinueDragHandler(_dragSource, queryContinue = new QueryContinueDragEventHandler(onQueryContinueDrag));
}
try
{
IsDragging = true;
this._mouseLeftScope = false;
resultEffects = System.Windows.DragDrop.DoDragDrop(_dragSource, data, effects);
DragFinished(resultEffects);
}
catch
{
}
if (DragScope != _dragSource)
{
DragScope.AllowDrop = previousAllowDrop;
System.Windows.DragDrop.RemovePreviewDragOverHandler(DragScope, dragOver);
System.Windows.DragDrop.RemovePreviewDragLeaveHandler(DragScope, dragLeave);
System.Windows.DragDrop.RemovePreviewQueryContinueDragHandler(_dragSource, queryContinue);
}
}
else
{
System.Windows.DragDrop.AddPreviewQueryContinueDragHandler(_dragSource, queryContinue = new QueryContinueDragEventHandler(onQueryContinueDrag));
System.Windows.DragDrop.AddGiveFeedbackHandler(_dragSource, giveFeedback = new GiveFeedbackEventHandler(onGiveFeedback));
IsDragging = true;
CreateDragDropWindow(dragelement);
this._dragdropWindow.Show();
try
{
resultEffects = System.Windows.DragDrop.DoDragDrop(_dragSource, data, effects);
}
finally { }
DestroyDragDropWindow();
System.Windows.DragDrop.RemovePreviewQueryContinueDragHandler(_dragSource, onQueryContinueDrag);
System.Windows.DragDrop.AddGiveFeedbackHandler(_dragSource, onGiveFeedback);
IsDragging = false;
DragFinished(resultEffects);
}
}
public ResourceTree()
{
SetStyle(ControlStyles.UserMouse, true);
_timer.Interval = 200;
_timer.Tick += new EventHandler(timer_Tick);
AllowDrop = true;
ItemDrag += new ItemDragEventHandler(treeView_ItemDrag);
DragOver += new DragEventHandler(treeView1_DragOver);
DragDrop += new DragEventHandler(treeView1_DragDrop);
DragEnter += new DragEventHandler(treeView1_DragEnter);
DragLeave += new EventHandler(treeView1_DragLeave);
GiveFeedback += new GiveFeedbackEventHandler(treeView1_GiveFeedback);
m_DelegateOpenFile = new DelegateOpenFile(ImportFile);
}
public static void RemovePreviewGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
UIElement.RemoveHandler(element, PreviewGiveFeedbackEvent, handler);
}
private void dtGridActors_PreviewMouseMove(object sender, MouseEventArgs e)
{
if (e.LeftButton == MouseButtonState.Pressed)// && !IsDragging)
{
int i = dtGridActors.SelectedIndex;
if (i < 0) return;
AtomDTOData currAtomData = (AtomDTOData)dtGridActors.Items[i];
Point position = e.GetPosition(null);
if (Math.Abs(position.X - _startPoint.X) > SystemParameters.MinimumHorizontalDragDistance ||
Math.Abs(position.Y - _startPoint.Y) > SystemParameters.MinimumVerticalDragDistance)
{
_allOpsCursor = null;
GiveFeedbackEventHandler handler = new GiveFeedbackEventHandler(dtGridActors_GiveFeedback);
this.dtGridActors.GiveFeedback += handler;
IsDragging = true;
try
{
DataObject data = new DataObject(typeof(FormationTree), currAtomData.atom);
data.SetText("Actor");
DragDropEffects de = DragDrop.DoDragDrop(dtGridActors, data, DragDropEffects.Move);
}
catch (Exception ex)
{
//this.treeViewForce.GiveFeedback -= handler;
//this.treeViewForce.GiveFeedback += handler;
}
this.dtGridActors.GiveFeedback -= handler;
IsDragging = false;
}
}
}
void StartDrag(MouseEventArgs args)
{
IDataObject data = null;
UIElement dragelement = null;
// ADD THE DATA
if (_callback != null)
{
DragDataWrapper dw = new DragDataWrapper();
data = new DataObject(typeof(DragDataWrapper).ToString(), dw);
if ((_callback.SupportedActions & DragDropProviderActions.MultiFormatData) != 0)
{
_callback.AppendData(ref data, args);
}
if ((_callback.SupportedActions & DragDropProviderActions.Data) != 0)
{
dw.Data = _callback.GetData();
}
if ((_callback.SupportedActions & DragDropProviderActions.Visual) != 0)
{
dragelement = _callback.GetVisual(args);
}
else
{
dragelement = args.OriginalSource as UIElement;
}
dw.Source = _dragSource;
dw.Shim = _callback;
// System.Diagnostics.Debug.Assert(DragScope == null, "The DragDataWrapper is meant for in-proc... Sorry for asserting, just wanted to confirm.. comment out assertion if needed");
}
else
{
dragelement = args.OriginalSource as UIElement;
data = new DataObject(typeof(UIElement).ToString(), dragelement);
}
if (dragelement == null || data == null || dragelement == this._dragSource)
{
return;
}
#if DEBUG
// Add it as Text ... good for testing purposes
if (!data.GetDataPresent(DataFormats.Text))
{
data.SetData(DataFormats.Text, "abcd");
}
#endif
DragEventHandler dragOver = null;
DragEventHandler dragLeave = null;
QueryContinueDragEventHandler queryContinue = null;
GiveFeedbackEventHandler giveFeedback = null;
DragDropEffects effects = GetDragDropEffects();
DragDropEffects resultEffects;
// Inprocess Drag ...
if (DragScope != null)
{
bool previousAllowDrop = DragScope.AllowDrop;
_adorner = new DragAdorner(DragScope, (UIElement)dragelement, true, Opacity);
_layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
_layer.Add(_adorner);
if (DragScope != _dragSource)
{
DragScope.AllowDrop = true;
DragDrop.AddPreviewDragOverHandler((DependencyObject)DragScope, dragOver = new DragEventHandler(DragScope_DragOver));
DragDrop.AddPreviewDragLeaveHandler(DragScope, dragLeave = new DragEventHandler(DragScope_DragLeave));
DragDrop.AddPreviewQueryContinueDragHandler(_dragSource, queryContinue = new QueryContinueDragEventHandler(onQueryContinueDrag));
}
try
{
IsDragging = true;
this._mouseLeftScope = false;
resultEffects = DragDrop.DoDragDrop(_dragSource, data, effects);
DragFinished(resultEffects);
}
catch
{
System.Diagnostics.Debug.Assert(false);
}
if (DragScope != _dragSource)
{
DragScope.AllowDrop = previousAllowDrop;
DragDrop.RemovePreviewDragOverHandler(DragScope, dragOver);
DragDrop.RemovePreviewDragLeaveHandler(DragScope, dragLeave);
DragDrop.RemovePreviewQueryContinueDragHandler(_dragSource, queryContinue);
}
}
else
{
DragDrop.AddPreviewQueryContinueDragHandler(_dragSource, queryContinue = new QueryContinueDragEventHandler(onQueryContinueDrag));
DragDrop.AddGiveFeedbackHandler(_dragSource, giveFeedback = new GiveFeedbackEventHandler(onGiveFeedback));
IsDragging = true;
CreateDragDropWindow(dragelement);
this._dragdropWindow.Show();
try
{
resultEffects = DragDrop.DoDragDrop(_dragSource, data, effects);
}
finally { }
DestroyDragDropWindow();
DragDrop.RemovePreviewQueryContinueDragHandler(_dragSource, onQueryContinueDrag);
DragDrop.AddGiveFeedbackHandler(_dragSource, onGiveFeedback);
IsDragging = false;
DragFinished(resultEffects);
}
}
public static void AddGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
UIElement.AddHandler(element, GiveFeedbackEvent, handler);
}
public static void AddPreviewGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
}
private static void StartDragInProcAdorner(DependencyObject source, DependencyObject dragElement)
{
// Let's define our DragScope .. In this case it is every thing inside our main window ..
//FrameworkElement DragScope = (source as FrameworkElement).Parent as FrameworkElement;
FrameworkElement DragScope = GetDragScope(source); // source as FrameworkElement;// Application.Current.MainWindow.Content as FrameworkElement;
SetHasDropped(dragElement, false);
// We enable Drag & Drop in our scope ... We are not implementing Drop, so it is OK, but this allows us to get DragOver
bool previousDrop = DragScope.AllowDrop;
DragScope.AllowDrop = true;
// Let's wire our usual events..
// GiveFeedback just tells it to use no standard cursors..
GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(source_GiveFeedback);
DragScope.GiveFeedback += feedbackhandler;
// The DragOver event ...
DragEventHandler draghandler = new DragEventHandler(DragOver);
DragScope.PreviewDragOver += draghandler;
// Drag Leave is optional, but write up explains why I like it ..
DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
DragScope.DragLeave += dragleavehandler;
// QueryContinue Drag goes with drag leave...
//QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
//DragScope.QueryContinueDrag += queryhandler;
//Here we create our adorner..
DragAdorner adorn = new DragAdorner(DragScope, (UIElement)dragElement, true, 1);
//DragAdorner adorn = new DragAdorner((FrameworkElement)source, (UIElement)dragElement, true, 0.5);
SetDragAdorner(DragScope, adorn);
AdornerLayer layr = AdornerLayer.GetAdornerLayer(DragScope as Visual);
layr.Add(adorn);
adorn.BringIntoView();
SetIsDragging(source, true);
SetDragHasLeftScope(source, false);
//Finally lets drag drop
//DataObject data = new DataObject(System.Windows.DataFormats.Text.ToString(), "abcd");
DataObject data = new DataObject(dragElement);
if (PreviewDragStarted != null)
{
DragStartedEventArgs eArg = new DragStartedEventArgs();
eArg.DragObject = dragElement;
PreviewDragStarted(DragScope, eArg);
}
//DragDropEffects de =
DragDrop.DoDragDrop(DragScope, data, DragDropEffects.Move);
// Clean up our mess :)
DragScope.AllowDrop = previousDrop;
//AdornerLayer.GetAdornerLayer(DragScope).Remove(GetDragAdorner(DragScope));
layr.Remove(adorn);
SetDragAdorner(source, null);
DragScope.GiveFeedback -= feedbackhandler;
DragScope.DragLeave -= dragleavehandler;
//DragScope.QueryContinueDrag -= queryhandler;
DragScope.PreviewDragOver -= draghandler;
SetIsDragging(source, false);
}
private void StartDrag(MouseEventArgs args)
{
IDataObject data = null;
UIElement dragelement = null;
// ADD THE DATA
if (this.Callback != null)
{
DragDataWrapper dw = new DragDataWrapper();
data = new DataObject(typeof(DragDataWrapper).ToString(), dw);
if ((this.Callback.SupportedActions & DragDropProviderActions.MultiFormatData) != 0)
{
this.Callback.AppendData(ref data, args);
}
if ((this.Callback.SupportedActions & DragDropProviderActions.Data) != 0)
{
dw.Data = this.Callback.GetData();
}
if ((this.Callback.SupportedActions & DragDropProviderActions.Visual) != 0)
{
dragelement = this.Callback.GetVisual(args);
}
else
{
dragelement = args.OriginalSource as UIElement;
}
dw.Source = this.DragSource;
dw.Shim = this.Callback;
Debug.Assert(this.DragScope == null, "The DragDataWrapper is meant for in-proc... Sorry for asserting, just wanted to confirm.. comment out assertion if needed");
}
else
{
dragelement = args.OriginalSource as UIElement;
data = new DataObject(typeof(UIElement).ToString(), dragelement);
}
if (dragelement == null || data == null || dragelement == this.DragSource)
{
return;
}
DragEventHandler dragOver = null;
DragEventHandler dragLeave = null;
QueryContinueDragEventHandler queryContinue = null;
GiveFeedbackEventHandler giveFeedback = null;
DragDropEffects effects = this.GetDragDropEffects();
DragDropEffects resultEffects;
// Inprocess Drag ...
if (this.DragScope != null)
{
bool previousAllowDrop = this.DragScope.AllowDrop;
this.adorner = new DragAdorner(this.DragScope, (UIElement)dragelement, true, this.Opacity);
this.layer = AdornerLayer.GetAdornerLayer(this.DragScope as Visual);
this.layer.Add(this.adorner);
if (this.DragScope != this.DragSource)
{
this.DragScope.AllowDrop = true;
DragDrop.AddPreviewDragOverHandler((DependencyObject)this.DragScope, dragOver = new DragEventHandler(DragScope_DragOver));
DragDrop.AddPreviewDragLeaveHandler(this.DragScope, dragLeave = new DragEventHandler(DragScope_DragLeave));
DragDrop.AddPreviewQueryContinueDragHandler(this.DragSource, queryContinue = new QueryContinueDragEventHandler(OnQueryContinueDrag));
}
try
{
this.IsDragging = true;
this.mouseLeftScope = false;
resultEffects = DragDrop.DoDragDrop(this.DragSource, data, effects);
this.DragFinished(resultEffects);
}
catch
{
Debug.Assert(false);
}
if (this.DragScope != this.DragSource)
{
this.DragScope.AllowDrop = previousAllowDrop;
DragDrop.RemovePreviewDragOverHandler(this.DragScope, dragOver);
DragDrop.RemovePreviewDragLeaveHandler(this.DragScope, dragLeave);
DragDrop.RemovePreviewQueryContinueDragHandler(this.DragSource, queryContinue);
}
}
else
{
DragDrop.AddPreviewQueryContinueDragHandler(this.DragSource, queryContinue = new QueryContinueDragEventHandler(OnQueryContinueDrag));
DragDrop.AddGiveFeedbackHandler(this.DragSource, giveFeedback = new GiveFeedbackEventHandler(OnGiveFeedback));
this.IsDragging = true;
if ((this.Callback.SupportedActions & DragDropProviderActions.Visual) != 0)
{
this.CreateDragDropWindow(dragelement);
this.dragdropWindow.Show();
}
try
{
resultEffects = DragDrop.DoDragDrop(this.DragSource, data, effects);
}
finally
{
}
if ((this.Callback.SupportedActions & DragDropProviderActions.Visual) != 0)
{
this.DestroyDragDropWindow();
}
DragDrop.RemovePreviewQueryContinueDragHandler(this.DragSource, OnQueryContinueDrag);
DragDrop.AddGiveFeedbackHandler(this.DragSource, OnGiveFeedback);
this.IsDragging = false;
this.DragFinished(resultEffects);
}
}
//------------------------------------------------------
//
// Protected Methods
//
//------------------------------------------------------
/// <summary>
/// The mechanism used to call the type-specific handler on the target.
/// </summary>
/// <param name="genericHandler">
/// The generic handler to call in a type-specific way.
/// </param>
/// <param name="genericTarget">
/// The target to call the handler on.
/// </param>
protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget)
{
GiveFeedbackEventHandler handler = (GiveFeedbackEventHandler)genericHandler;
handler(genericTarget, this);
}
private void DoDragDrop()
{
// Let's define our DragScope .. In this case it is every thing inside our main window ..
m_DragScope = (FrameworkElement)Chart;
m_DragSource = this;
Debug.Assert(m_DragScope != null);
Debug.Assert(m_DragSource != null);
// We enable Drag & Drop in our scope ... We are not implementing Drop, so it is OK, but this allows us to get DragOver
bool previousDrop = m_DragScope.AllowDrop;
m_DragScope.AllowDrop = true;
// Let's wire our usual events..
// GiveFeedback just tells it to use no standard cursors..
GiveFeedbackEventHandler feedbackhandler = DragSource_GiveFeedback;
m_DragScope.GiveFeedback += feedbackhandler;
// The DragOver event ...
DragEventHandler draghandler = DragSource_DragOver;
m_DragScope.PreviewDragOver += draghandler;
// Drag Leave is optional, but write up explains why I like it ..
DragEventHandler dragleavehandler = DragScope_DragLeave;
m_DragScope.DragLeave += dragleavehandler;
// QueryContinue Drag goes with drag leave...
QueryContinueDragEventHandler queryhandler = DragScope_QueryContinueDrag;
m_DragScope.QueryContinueDrag += queryhandler;
// Here we create our adorner..
var adorner = new DragAdorner(m_DragScope, this, true, 0.5);
var layer = AdornerLayer.GetAdornerLayer(m_DragScope);
layer.Add(adorner);
m_IsDragging = true;
m_DragHasLeftScope = false;
// Finally lets drag drop
var data = new DataObject("DragModel", new DragModel {
Adorner = adorner, Source = this
});
DragDrop.DoDragDrop(m_DragSource, data, DragDropEffects.Move);
// Clean up mess
m_DragScope.AllowDrop = previousDrop;
AdornerLayer.GetAdornerLayer(m_DragScope).Remove(adorner);
m_DragSource.GiveFeedback -= feedbackhandler;
m_DragScope.DragLeave -= dragleavehandler;
m_DragScope.QueryContinueDrag -= queryhandler;
m_DragScope.PreviewDragOver -= draghandler;
m_IsDragging = false;
}
void StartDrag(MouseEventArgs args)
{
IDataObject data = null;
UIElement dragelement = null;
// ADD THE DATA
if (_callback != null)
{
DragDataWrapper dw = new DragDataWrapper();
data = new DataObject(typeof(DragDataWrapper).ToString(), dw);
if ((_callback.SupportedActions & DragDropProviderActions.MultiFormatData) != 0)
_callback.AppendData(ref data, args);
if ((_callback.SupportedActions & DragDropProviderActions.Data) != 0)
dw.Data = _callback.GetData();
if ((_callback.SupportedActions & DragDropProviderActions.Visual) != 0)
dragelement = _callback.GetVisual(args);
else
dragelement = args.OriginalSource as UIElement;
dw.Source = _dragSource;
dw.Shim = _callback;
System.Diagnostics.Debug.Assert(DragScope == null, "The DragDataWrapper is meant for in-proc... Sorry for asserting, just wanted to confirm.. comment out assertion if needed");
}
else
{
dragelement = args.OriginalSource as UIElement;
data = new DataObject(typeof(UIElement).ToString(), dragelement);
}
if (dragelement == null || data == null || dragelement == this._dragSource)
return;
#if DEBUG
// Add it as Text ... good for testing purposes
if ( !data.GetDataPresent(DataFormats.Text))
data.SetData(DataFormats.Text, "abcd" );
#endif
DragEventHandler dragOver = null;
DragEventHandler dragLeave = null;
QueryContinueDragEventHandler queryContinue = null;
GiveFeedbackEventHandler giveFeedback = null;
DragDropEffects effects = GetDragDropEffects();
DragDropEffects resultEffects;
// Inprocess Drag ...
if (DragScope != null)
{
bool previousAllowDrop = DragScope.AllowDrop;
_adorner = new DragAdorner(DragScope, (UIElement)dragelement, true, Opacity);
_layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
_layer.Add(_adorner);
if (DragScope != _dragSource)
{
DragScope.AllowDrop = true;
DragDrop.AddPreviewDragOverHandler((DependencyObject)DragScope, dragOver = new DragEventHandler(DragScope_DragOver));
DragDrop.AddPreviewDragLeaveHandler(DragScope, dragLeave = new DragEventHandler(DragScope_DragLeave));
DragDrop.AddPreviewQueryContinueDragHandler(_dragSource, queryContinue = new QueryContinueDragEventHandler(onQueryContinueDrag));
}
try
{
IsDragging = true;
this._mouseLeftScope = false;
resultEffects = DragDrop.DoDragDrop(_dragSource, data, effects);
DragFinished(resultEffects);
}
catch
{
System.Diagnostics.Debug.Assert(false);
}
if (DragScope != _dragSource)
{
DragScope.AllowDrop = previousAllowDrop;
DragDrop.RemovePreviewDragOverHandler(DragScope, dragOver);
DragDrop.RemovePreviewDragLeaveHandler(DragScope, dragLeave);
DragDrop.RemovePreviewQueryContinueDragHandler(_dragSource, queryContinue );
}
}
else
{
DragDrop.AddPreviewQueryContinueDragHandler(_dragSource, queryContinue = new QueryContinueDragEventHandler(onQueryContinueDrag));
DragDrop.AddGiveFeedbackHandler(_dragSource, giveFeedback = new GiveFeedbackEventHandler( onGiveFeedback));
IsDragging = true;
CreateDragDropWindow(dragelement);
this._dragdropWindow.Show();
try
{
resultEffects = DragDrop.DoDragDrop(_dragSource, data, effects);
}
finally { }
DestroyDragDropWindow();
DragDrop.RemovePreviewQueryContinueDragHandler(_dragSource, onQueryContinueDrag);
DragDrop.AddGiveFeedbackHandler(_dragSource, onGiveFeedback);
IsDragging = false;
DragFinished(resultEffects);
}
}
private void StartDragInProcAdorner(MouseEventArgs e)
{
// Let's define our DragScope .. In this case it is every thing inside our main window ..
DragScope = Application.Current.MainWindow.Content as FrameworkElement;
System.Diagnostics.Debug.Assert(DragScope != null);
// We enable Drag & Drop in our scope ... We are not implementing Drop, so it is OK, but this allows us to get DragOver
bool previousDrop = DragScope.AllowDrop;
DragScope.AllowDrop = true;
// Let's wire our usual events..
// GiveFeedback just tells it to use no standard cursors..
GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
this.GiveFeedback += feedbackhandler;
// Drag Leave is optional, but write up explains why I like it ..
DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
DragScope.DragLeave += dragleavehandler;
// QueryContinue Drag goes with drag leave...
QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
DragScope.QueryContinueDrag += queryhandler;
//Here we create our adorner..
if(null == OnDragDisplayPropertyName) throw new Exception("OnDragDisplayPropertyName must have a value to enable drag'n'drop");
List<string> dragDisplayNames = new List<string>();
//iterate through the 'items' collection, and check to see if each item is contained in the list of selected items. we do this because 'selecteditems' ordering is sometimes quite random...
List<object> selectedItemsOrdered = new List<object>();
foreach (var item in Items)
{
if (SelectedItems.Contains(item))
{
selectedItemsOrdered.Add(item);
}
}
foreach (var item in selectedItemsOrdered)
{
dragDisplayNames.Add((string)item.GetType().GetProperty(OnDragDisplayPropertyName).GetValue(item, null));
}
_adorner = new TextListAdorner(DragScope, dragDisplayNames);
DragScope.DragOver += new DragEventHandler(DragScope_DragOver);
_layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
_layer.Add(_adorner);
//note the selected items in a collection, for use later...
_draggedItems = new List<object>();
foreach (var item in SelectedItems)
{
_draggedItems.Add(item);
}
IsDragging = true;
_dragHasLeftScope = false;
//Finally lets drag drop
DataObject data = new DataObject(System.Windows.DataFormats.Text.ToString(), "abcd");
DragDropEffects de = DragDrop.DoDragDrop(this, data, DragDropEffects.Move);
// Clean up our mess :) -- this code is executed when the drag'n'drop operation is completed.
DragScope.AllowDrop = previousDrop;
AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
_adorner = null;
//if we're dropping the dragged items onto an item that isn't in the list of dragged items...
if (SelectedItem == null || false == _draggedItems.Contains(SelectedItem))
{
var targetIndex = Items.IndexOf(SelectedItem);
//execute the command, to allow the control using the datagrid to handle moving the items
MoveItemsCommand.Execute(new MoveItemsCommandParameter(targetIndex, selectedItemsOrdered));
}
//select the dropped items
SelectedItems.Clear();
_draggedItems.ForEach(x => SelectedItems.Add(x));
_draggedItems = null;
this.GiveFeedback -= feedbackhandler;
DragScope.DragLeave -= dragleavehandler;
DragScope.QueryContinueDrag -= queryhandler;
DragScope.DragOver -= DragScope_DragOver;
IsDragging = false;
_isClickingDownOnSelectedItem = false;
}
public static void RemoveGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
}
/// <summary>
/// Removes a handler from the attached GiveFeedback event.
/// </summary>
/// <param name="element">The DependencyObject to attach an event handler for.</param>
/// <param name="handler">The event handler.</param>
internal static void RemoveGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
ExtendedRoutedEventHandlerCollection<GiveFeedbackEventHandler, GiveFeedbackEventArgs> handlers = element.GetGiveFeedbackHandlers();
if (handlers != null)
{
handlers.Remove(handler);
}
}
/// <summary>
/// Adds a handler for the GiveFeedback attached event
/// </summary>
/// <param name="element">UIElement or ContentElement that listens to this event</param>
/// <param name="handler">Event Handler to be added</param>
public static void AddGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
UIElement.AddHandler(element, GiveFeedbackEvent, handler);
}
/// <summary>
/// Adds a handler to the attached GiveFeedback event.
/// </summary>
/// <param name="element">The DependencyObject to attach an event handler for.</param>
/// <param name="handler">The event handler.</param>
/// <param name="handledEventsToo">A value Indicating whether to invoke the
/// handler if the event has been handled.</param>
internal static void AddGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler, bool handledEventsToo)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
ExtendedRoutedEventHandlerCollection<GiveFeedbackEventHandler, GiveFeedbackEventArgs> originalHandlers = element.GetGiveFeedbackHandlers();
ExtendedRoutedEventHandlerCollection<GiveFeedbackEventHandler, GiveFeedbackEventArgs> handlers = originalHandlers ?? new ExtendedRoutedEventHandlerCollection<GiveFeedbackEventHandler, GiveFeedbackEventArgs>((h, a) => h(element, a));
handlers.Add(handler, handledEventsToo);
if (handlers != originalHandlers)
{
element.SetValue(GiveFeedbackHandlerProperty, handlers);
}
}
private void myDataGrid_MouseMove(object sender, MouseEventArgs e)
{
if (e.LeftButton == MouseButtonState.Pressed)
{
GiveFeedbackEventHandler handler = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
DataGrid grid = sender as DataGrid;
object selectedItem = grid.SelectedItem;
if (selectedItem != null)
{
DataGridRow row = (DataGridRow)grid.ItemContainerGenerator.ContainerFromItem(selectedItem);
//comment out this wiring to feedback handler to take off custom cursor
row.GiveFeedback += handler;
changeItem item = (changeItem)row.Item;
DataObject dragData = new DataObject("changeItem", item);
if (row != null)
{
DragDropEffects finalDropEffect = DragDrop.DoDragDrop(row, dragData, DragDropEffects.Move);
}
}
}
}
/// <summary>
/// Adds a handler to the attached GiveFeedback event.
/// </summary>
/// <param name="element">The DependencyObject to attach an event handler for.</param>
/// <param name="handler">The event handler.</param>
internal static void AddGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
AddGiveFeedbackHandler(element, handler, false);
}
private void StartDrag(MouseEventArgs mouseEventArgs, TreeView treeView, TreeViewItem item)
{
// Can only drop actual favorites (or favorite groups)...
DataObject data = null;
var selectedItem = treeView.SelectedItem as HierarchicalViewModelBase;
if (selectedItem is FavoriteViewModel <T> )
{
var selected = treeView.SelectedItem as FavoriteViewModel <T>;
string desc = "";
data = new DataObject(typeof(T).Name, selected);
if (selected.IsGroup)
{
desc = String.Format("Favorite Folder: Name={0} [FavoriteID={1}]", selected.GroupName, selected.FavoriteID);
}
else
{
desc = String.Format("{0} : Name={1} [ID1={2}, ID2={3}, FavoriteID={4}]", typeof(T).Name, selected.DisplayLabel, selected.Model.ID1, selected.Model.ID2, selected.FavoriteID);
data.SetData(PinnableObject.DRAG_FORMAT_NAME, Provider.CreatePinnableObject(selected));
}
data.SetData(DataFormats.Text, desc);
}
else if (selectedItem is V)
{
data = new DataObject(PinnableObject.DRAG_FORMAT_NAME, Provider.CreatePinnableObject(treeView.SelectedItem as V));
}
if (data != null)
{
_dropScope = treeView;
_dropScope.AllowDrop = true;
GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DropScope_GiveFeedback);
item.GiveFeedback += feedbackhandler;
var handler = new DragEventHandler((s, e) => {
TreeViewItem destItem = GetHoveredTreeViewItem(e);
e.Effects = DragDropEffects.None;
if (destItem != null)
{
destItem.IsSelected = true;
var destModel = destItem.Header as FavoriteViewModel <T>;
if (destModel != selectedItem && !selectedItem.IsAncestorOf(destModel))
{
if (destModel != null)
{
if (destModel.IsGroup)
{
e.Effects = DragDropEffects.Move;
}
}
else
{
if (destItem.Header is ViewModelPlaceholder)
{
e.Effects = DragDropEffects.Move;
}
}
}
}
e.Handled = true;
});
treeView.PreviewDragEnter += handler;
treeView.PreviewDragOver += handler;
var dropHandler = new DragEventHandler(treeView_Drop);
treeView.Drop += dropHandler;
try {
_IsDragging = true;
DragDrop.DoDragDrop(item, data, DragDropEffects.Copy | DragDropEffects.Move | DragDropEffects.Link);
} finally {
_IsDragging = false;
treeView.PreviewDragEnter -= handler;
treeView.PreviewDragOver -= handler;
treeView.Drop -= dropHandler;
}
}
InvalidateVisual();
}
/// <summary>
/// Prepare for and begin a drag operation.
/// Hook the events needed by the data provider.
/// </summary>
private DragDropEffects DoDragDrop_Start(MouseEventArgs e)
{
DragDropEffects resultEffects = DragDropEffects.None;
DataObject data = new DataObject();
this._dragDropObject.SetData(ref data);
bool hookQueryContinueDrag = false;
bool hookGiveFeedback = false;
if ((this._dragDropObject.DataProviderActions & DataProviderActions.QueryContinueDrag) != 0)
{
hookQueryContinueDrag = true;
}
if ((this._dragDropObject.DataProviderActions & DataProviderActions.GiveFeedback) != 0)
{
hookGiveFeedback = true;
}
if (this._dragDropObject.AddAdorner)
{
hookGiveFeedback = true;
}
QueryContinueDragEventHandler queryContinueDrag = null;
GiveFeedbackEventHandler giveFeedback = null;
if (hookQueryContinueDrag)
{
queryContinueDrag = new QueryContinueDragEventHandler(DragSource_QueryContinueDrag);
this._dragSource.QueryContinueDrag += queryContinueDrag;
}
if (hookGiveFeedback)
{
giveFeedback = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
this._dragSource.GiveFeedback += giveFeedback;
}
try {
// NOTE: Set 'dragSource' to desired value (dragSource or item being dragged)
// 'dragSource' is passed to QueryContinueDrag as Source and OriginalSource
DependencyObject dragSource;
dragSource = this._dragSource;
//dragSource = this._dragDropObject.Item;
resultEffects = DragDrop.DoDragDrop(dragSource, data, this._dragDropObject.AllowedEffects);
}
catch {
Debug.WriteLine("DragDrop.DoDragDrop threw an exception");
}
if (queryContinueDrag != null)
{
this._dragSource.QueryContinueDrag -= queryContinueDrag;
}
if (giveFeedback != null)
{
this._dragSource.GiveFeedback -= giveFeedback;
}
return(resultEffects);
}
private void StartDragInProcAdorner(MouseEventArgs e)
{
// Let's define our DragScope .. In this case it is every thing inside our main window ..
DragScope = Program.ClientWindow.Content as FrameworkElement;
System.Diagnostics.Debug.Assert(DragScope != null);
// We enable Drag & Drop in our scope ... We are not implementing Drop, so it is OK, but this allows us to get DragOver
bool previousDrop = DragScope.AllowDrop;
DragScope.AllowDrop = true;
// Let's wire our usual events..
// GiveFeedback just tells it to use no standard cursors..
GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
this.GiveFeedback += feedbackhandler;
// The DragOver event ...
DragEventHandler draghandler = new DragEventHandler(Window1_DragOver);
DragScope.PreviewDragOver += draghandler;
// Drag Leave is optional, but write up explains why I like it ..
DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
DragScope.DragLeave += dragleavehandler;
// QueryContinue Drag goes with drag leave...
QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
DragScope.QueryContinueDrag += queryhandler;
//Here we create our adorner..
_adorner = new DragAdorner(DragScope, (UIElement)this, true, 0.5);
_layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
_layer.Add(_adorner);
IsDragging = true;
_dragHasLeftScope = false;
//Finally lets drag drop
DataObject data = new DataObject(System.Windows.DataFormats.Text.ToString(), "abcd");
DragDropEffects de = DragDrop.DoDragDrop(this, data, DragDropEffects.Move);
// Clean up our mess :)
DragScope.AllowDrop = previousDrop;
AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
_adorner = null;
GiveFeedback -= feedbackhandler;
DragScope.DragLeave -= dragleavehandler;
DragScope.QueryContinueDrag -= queryhandler;
DragScope.PreviewDragOver -= draghandler;
IsDragging = false;
}
private void StartDragWindow(MouseEventArgs e)
{
GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DragSource_GiveFeedback); ;
this.GiveFeedback += feedbackhandler;
QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragSource_QueryContinueDrag);
this.QueryContinueDrag += queryhandler;
IsDragging = true;
CreateDragDropWindow(this);
//DataObject data = new DataObject(System.Windows.DataFormats.Text.ToString(), "abcd");
DataObject data = new DataObject(System.Windows.DataFormats.Text, m_User.Uid.ToString());
//DataObject data = new DataObject(this.m_User);
this._dragdropWindow.Show();
DragDropEffects de = DragDrop.DoDragDrop(this, data, DragDropEffects.Move);
DestroyDragDropWindow();
IsDragging = false;
this.GiveFeedback -= feedbackhandler;
this.QueryContinueDrag -= queryhandler;
}
/// <summary>
/// Prepare for and begin a drag operation.
/// Hook the events needed by the data provider.
/// </summary>
private DragDropEffects DoDragDrop_Start(MouseEventArgs e) {
DragDropEffects resultEffects = DragDropEffects.None;
DataObject data = new DataObject();
this._dragDropObject.SetData(ref data);
bool hookQueryContinueDrag = false;
bool hookGiveFeedback = false;
if((this._dragDropObject.DataProviderActions & DataProviderActions.QueryContinueDrag) != 0)
hookQueryContinueDrag = true;
if((this._dragDropObject.DataProviderActions & DataProviderActions.GiveFeedback) != 0)
hookGiveFeedback = true;
if(this._dragDropObject.AddAdorner)
hookGiveFeedback = true;
QueryContinueDragEventHandler queryContinueDrag = null;
GiveFeedbackEventHandler giveFeedback = null;
if(hookQueryContinueDrag) {
queryContinueDrag = new QueryContinueDragEventHandler(DragSource_QueryContinueDrag);
this._dragSource.QueryContinueDrag += queryContinueDrag;
}
if(hookGiveFeedback) {
giveFeedback = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
this._dragSource.GiveFeedback += giveFeedback;
}
try {
// NOTE: Set 'dragSource' to desired value (dragSource or item being dragged)
// 'dragSource' is passed to QueryContinueDrag as Source and OriginalSource
DependencyObject dragSource;
dragSource = this._dragSource;
//dragSource = this._dragDropObject.Item;
resultEffects = DragDrop.DoDragDrop(dragSource, data, this._dragDropObject.AllowedEffects);
}
catch {
Debug.WriteLine("DragDrop.DoDragDrop threw an exception");
//TODO: Add log here
}
if(queryContinueDrag != null)
this._dragSource.QueryContinueDrag -= queryContinueDrag;
if(giveFeedback != null)
this._dragSource.GiveFeedback -= giveFeedback;
return resultEffects;
}
void StartDrag(MouseEventArgs args)
{
IDataObject data = null;
UIElement dragelement = null;
// ADD THE DATA
if (_callback != null)
{
DragDataWrapper dw = new DragDataWrapper();
data = new DataObject(typeof(DragDataWrapper).ToString(), dw);
if ((_callback.SupportedActions & DragDropProviderActions.MultiFormatData) != 0)
{
_callback.AppendData(ref data, args);
}
if ((_callback.SupportedActions & DragDropProviderActions.Data) != 0)
{
dw.Data = _callback.GetData();
}
if ((_callback.SupportedActions & DragDropProviderActions.Visual) != 0)
{
dragelement = _callback.GetVisual(args);
}
else
{
dragelement = args.OriginalSource as UIElement;
}
dw.Source = _dragSource;
dw.Shim = _callback;
}
else
{
dragelement = args.OriginalSource as UIElement;
data = new DataObject(typeof(UIElement).ToString(), dragelement);
}
// mwa changed from:
// if (dragelement == null || data == null || dragelement == this._dragSource)
if (dragelement == null || data == null)
{
return;
}
DragEventHandler dragOver = null;
DragEventHandler dragLeave = null;
QueryContinueDragEventHandler queryContinue = null;
GiveFeedbackEventHandler giveFeedback = null;
DragDropEffects effects = GetDragDropEffects();
DragDropEffects resultEffects;
// Inprocess Drag ...
if (DragScope != null)
{
bool previousAllowDrop = DragScope.AllowDrop;
_adorner = new DragAdorner(DragScope, (UIElement)dragelement, true, Opacity);
_layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
_layer.Add(_adorner);
if (DragScope != _dragSource)
{
DragScope.AllowDrop = true;
System.Windows.DragDrop.AddPreviewDragOverHandler((DependencyObject)DragScope, dragOver = new DragEventHandler(DragScope_DragOver));
System.Windows.DragDrop.AddPreviewDragLeaveHandler(DragScope, dragLeave = new DragEventHandler(DragScope_DragLeave));
System.Windows.DragDrop.AddPreviewQueryContinueDragHandler(_dragSource, queryContinue = new QueryContinueDragEventHandler(onQueryContinueDrag));
}
try
{
IsDragging = true;
this._mouseLeftScope = false;
resultEffects = System.Windows.DragDrop.DoDragDrop(_dragSource, data, effects);
DragFinished(resultEffects);
}
catch
{
}
if (DragScope != _dragSource)
{
DragScope.AllowDrop = previousAllowDrop;
System.Windows.DragDrop.RemovePreviewDragOverHandler(DragScope, dragOver);
System.Windows.DragDrop.RemovePreviewDragLeaveHandler(DragScope, dragLeave);
System.Windows.DragDrop.RemovePreviewQueryContinueDragHandler(_dragSource, queryContinue);
}
}
else
{
System.Windows.DragDrop.AddPreviewQueryContinueDragHandler(_dragSource, queryContinue = new QueryContinueDragEventHandler(onQueryContinueDrag));
System.Windows.DragDrop.AddGiveFeedbackHandler(_dragSource, giveFeedback = new GiveFeedbackEventHandler(onGiveFeedback));
IsDragging = true;
CreateDragDropWindow(dragelement);
this._dragdropWindow.Show();
try
{
resultEffects = System.Windows.DragDrop.DoDragDrop(_dragSource, data, effects);
}
finally { }
DestroyDragDropWindow();
System.Windows.DragDrop.RemovePreviewQueryContinueDragHandler(_dragSource, onQueryContinueDrag);
System.Windows.DragDrop.AddGiveFeedbackHandler(_dragSource, onGiveFeedback);
IsDragging = false;
DragFinished(resultEffects);
}
}
private void StartDrag(MouseEventArgs mouseEventArgs, TreeView treeView, TreeViewItem item)
{
// dragging actual favorites (or favorite groups)...
var selected = treeView.SelectedItem as TaxonFavoriteViewModel;
if (selected != null)
{
string desc = "";
var data = new DataObject("TaxonFavorite", selected);
if (selected.IsGroup)
{
desc = String.Format("Favorite Folder: Name={0} [FavoriteID={1}]", selected.TaxaFullName, selected.FavoriteID);
}
else
{
desc = String.Format("Taxon Favorite: Name={0} [TaxonID={1}, FavoriteID={2}]", selected.TaxaFullName, selected.TaxaID, selected.FavoriteID);
data.SetData(PinnableObject.DRAG_FORMAT_NAME, TaxonExplorer.Owner.CreatePinnableTaxon(selected.TaxaID));
}
data.SetData(DataFormats.Text, desc);
_dropScope = treeView;
_dropScope.AllowDrop = true;
GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DropScope_GiveFeedback);
item.GiveFeedback += feedbackhandler;
var handler = new DragEventHandler((s, e) => {
TreeViewItem destItem = GetHoveredTreeViewItem(e);
e.Effects = DragDropEffects.None;
if (destItem != null)
{
destItem.IsSelected = true;
var destModel = destItem.Header as TaxonFavoriteViewModel;
if (destModel != null)
{
if (destModel.IsGroup)
{
e.Effects = DragDropEffects.Move;
}
}
else
{
if (destItem.Header is ViewModelPlaceholder)
{
e.Effects = DragDropEffects.Move;
}
}
}
e.Handled = true;
});
treeView.PreviewDragEnter += handler;
treeView.PreviewDragOver += handler;
var dropHandler = new DragEventHandler(treeView_Drop);
treeView.Drop += dropHandler;
try {
_IsDragging = true;
DragDrop.DoDragDrop(item, data, DragDropEffects.Copy | DragDropEffects.Move | DragDropEffects.Link);
} finally {
_IsDragging = false;
treeView.PreviewDragEnter -= handler;
treeView.PreviewDragOver -= handler;
treeView.Drop -= dropHandler;
}
}
else
{
var taxon = treeView.SelectedItem as TaxonViewModel;
if (taxon != null)
{
DataObject data = new DataObject("Taxon", taxon);
data.SetData(PinnableObject.DRAG_FORMAT_NAME, TaxonExplorer.Owner.CreatePinnableTaxon(taxon.TaxaID.Value));
data.SetData(DataFormats.Text, taxon.TaxaFullName);
data.SetData(DataFormats.UnicodeText, taxon.TaxaFullName);
data.SetData(DataFormats.StringFormat, taxon.TaxaFullName);
try {
_IsDragging = true;
DragDrop.DoDragDrop(item, data, DragDropEffects.Copy | DragDropEffects.Move | DragDropEffects.Link);
} finally {
_IsDragging = false;
}
}
}
InvalidateVisual();
}
public static void AddPreviewGiveFeedbackHandler(DependencyObject element, GiveFeedbackEventHandler handler)
{
}
