private void StartDragGrid(object sender, MouseButtonEventArgs e) {
Grid g = (Grid)sender;
DragScope = Application.Current.MainWindow.Content as FrameworkElement;
bool previousDrop = DragScope.AllowDrop;
DragScope.AllowDrop = true;
DragEventHandler draghandler = new DragEventHandler(Window1_DragOver);
DragScope.PreviewDragOver += draghandler;
DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
DragScope.DragLeave += dragleavehandler;
QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
DragScope.QueryContinueDrag += queryhandler;
_adorner = new DragAdorner(DragScope, (UIElement)g, true, 0.5);
_layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
_layer.Add(_adorner);
IsDragging = true;
_dragHasLeftScope = false;
//NEEEEEEEEEEEEEEEEEEEEEEEEEED TO CHANGE
TextBlock name = (TextBlock) g.Children[0];
TextBlock duration = (TextBlock) g.Children[1];
TextBlock path = (TextBlock)g.Children[2];
String content = g.Tag.ToString() + "#" + path.Text + "#" + duration.Text;
DataObject data = new DataObject(System.Windows.DataFormats.Text.ToString(), content);
DragDropEffects de = DragDrop.DoDragDrop(g, data, DragDropEffects.Move);
// Clean up our mess :)
DragScope.AllowDrop = previousDrop;
AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
_adorner = null;
DragScope.DragLeave -= dragleavehandler;
DragScope.QueryContinueDrag -= queryhandler;
DragScope.PreviewDragOver -= draghandler;
IsDragging = false;
}
private void StartDragInProcAdorner(MouseEventArgs e, dynamic sender)
{
// Let's define our DragScope .. In this case it is every thing inside our main window ..
DragScope = this.canGUI 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.DragSource.GiveFeedback += feedbackhandler;
// The DragOver event ...
DragEventHandler draghandler = new DragEventHandler(Window1_DragOver);
DragScope.DragOver += 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)sender, 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.canGUI, data, DragDropEffects.Move);
// Clean up our mess :)
DragScope.AllowDrop = previousDrop;
AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
_adorner = null;
//DragSource.GiveFeedback -= feedbackhandler;
DragScope.DragLeave -= dragleavehandler;
DragScope.QueryContinueDrag -= queryhandler;
IsDragging = false;
}
/// <summary>
/// Removes a handler for the QueryContinueDrag 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 RemoveQueryContinueDragHandler(DependencyObject element, QueryContinueDragEventHandler handler)
{
UIElement.RemoveHandler(element, QueryContinueDragEvent, handler);
}
/// <summary>
/// Adds a handler for the PreviewQueryContinueDrag 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 AddPreviewQueryContinueDragHandler(DependencyObject element, QueryContinueDragEventHandler handler)
{
UIElement.AddHandler(element, PreviewQueryContinueDragEvent, handler);
}
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 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);
}
}
public static void AddQueryContinueDragHandler(DependencyObject element, QueryContinueDragEventHandler handler)
{
}
/// <summary>
/// Adds a handler to the attached QueryContinueDrag event.
/// </summary>
/// <param name="element">The DependencyObject to attach an event handler for.</param>
/// <param name="handler">The event handler.</param>
internal static void AddQueryContinueDragHandler(DependencyObject element, QueryContinueDragEventHandler handler)
{
AddQueryContinueDragHandler(element, handler, 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>
/// Removes a handler from the attached QueryContinueDrag event.
/// </summary>
/// <param name="element">The DependencyObject to attach an event handler for.</param>
/// <param name="handler">The event handler.</param>
internal static void RemoveQueryContinueDragHandler(DependencyObject element, QueryContinueDragEventHandler handler)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
ExtendedRoutedEventHandlerCollection<QueryContinueDragEventHandler, QueryContinueDragEventArgs> handlers = element.GetQueryContinueDragHandlers();
if (handlers != null)
{
handlers.Remove(handler);
}
}
/// <summary>
/// Adds a handler to the attached QueryContinueDrag 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 AddQueryContinueDragHandler(DependencyObject element, QueryContinueDragEventHandler handler, bool handledEventsToo)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
ExtendedRoutedEventHandlerCollection<QueryContinueDragEventHandler, QueryContinueDragEventArgs> originalHandlers = element.GetQueryContinueDragHandlers();
ExtendedRoutedEventHandlerCollection<QueryContinueDragEventHandler, QueryContinueDragEventArgs> handlers = originalHandlers ?? new ExtendedRoutedEventHandlerCollection<QueryContinueDragEventHandler, QueryContinueDragEventArgs>((h, a) => h(element, a));
handlers.Add(handler, handledEventsToo);
if (handlers != originalHandlers)
{
element.SetValue(QueryContinueDragHandlerProperty, handlers);
}
}
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;
}
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;
}
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 StartDragSubItem(object sender, MouseEventArgs e)
{
TreeViewItem tvi2 = (TreeViewItem)sender;
DragScope = Application.Current.MainWindow.Content as FrameworkElement;
bool previousDrop = DragScope.AllowDrop;
DragScope.AllowDrop = true;
DragEventHandler draghandler = new DragEventHandler(Window1_DragOver);
DragScope.PreviewDragOver += draghandler;
DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
DragScope.DragLeave += dragleavehandler;
QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
DragScope.QueryContinueDrag += queryhandler;
_adorner = new DragAdorner(DragScope, (UIElement)this.tvi, true, 0.5);
_layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
_layer.Add(_adorner);
IsDragging = true;
_dragHasLeftScope = false;
DataObject data = new DataObject(System.Windows.DataFormats.Text.ToString(), tvi2.Tag);
DragDropEffects de = DragDrop.DoDragDrop(tvi2, data, DragDropEffects.Move);
// Clean up our mess :)
DragScope.AllowDrop = previousDrop;
AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
_adorner = null;
DragScope.DragLeave -= dragleavehandler;
DragScope.QueryContinueDrag -= queryhandler;
DragScope.PreviewDragOver -= draghandler;
IsDragging = false;
}
public CASTreeViewBase()
{
pErr = new Error();
mICol = null;
pIsMaySelectedNode = false;
mFindText = string.Empty;
mIsMatchCase = false;
mIsWordWhole = false;
mIsLocking = false;
_prevTreeNodeSelected = null;
DoubleClick += new System.EventHandler(OnDoubleClickTreeItem);
MouseDown += new System.Windows.Forms.MouseEventHandler(OnMouseDown);
BeforeLabelEdit += new NodeLabelEditEventHandler (OnBeforeLabelEdit);
AfterLabelEdit += new NodeLabelEditEventHandler (OnAfterLabelEdit);
mMIDel = null;
mMIIns = null;
mMIChoice = null;
mMIRename = null;
mMIProp = null;
mMIFind = null;
#region DragAndDrop:
AllowDrop = false; // �� ��������� - ��������� !!!
DragEnter+=new DragEventHandler(this_DragEnter);
DragOver+=new DragEventHandler(this_DragOver);
ItemDrag+=new ItemDragEventHandler(this_ItemDrag);
QueryContinueDrag+=new QueryContinueDragEventHandler(this_QueryContinueDrag);
DragDrop+=new DragEventHandler(this_DragDrop);
#endregion
}
public void StartDragDataGrid(object sender, MouseEventArgs e)
{
DataGridRow dgr = (DataGridRow)sender;
// Let's define our DragScope .. In this case it is every thing inside our main window ..
DragScope = Application.Current.MainWindow.Content as FrameworkElement;
// 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;
// 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.dg, true, 0.5);
_layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
_layer.Add(_adorner);
IsDragging = true;
_dragHasLeftScope = false;
//Finally lets drag drop
string content = "dgr" + "#" + dgr.Tag.ToString();
DataObject data = new DataObject(System.Windows.DataFormats.Text.ToString(), content);
DragDropEffects de = DragDrop.DoDragDrop(dgr, data, DragDropEffects.Move);
// Clean up our mess :)
DragScope.AllowDrop = previousDrop;
AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
_adorner = null;
DragScope.DragLeave -= dragleavehandler;
DragScope.QueryContinueDrag -= queryhandler;
DragScope.PreviewDragOver -= draghandler;
IsDragging = false;
}
private void StartDrag(MouseEventArgs mouseEvent, TaxonViewModel taxon, FrameworkElement item, FrameworkElement dropScope)
{
_dropScope = dropScope;
bool previousDrop = _dropScope.AllowDrop;
_dropScope.AllowDrop = true;
DragEventHandler drophandler = new DragEventHandler(_dragScope_Drop);
_dropScope.Drop += drophandler;
DragEventHandler draghandler = new DragEventHandler(DropSink_DragOver);
_dropScope.PreviewDragOver += draghandler;
DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
_dropScope.DragLeave += dragleavehandler;
QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
_dropScope.QueryContinueDrag += queryhandler;
var previewHandler = new DragEventHandler((s, evt) => {
if (!IsUnlocked) {
evt.Effects = DragDropEffects.None;
} else {
evt.Effects = DragDropEffects.Move;
}
evt.Handled = true;
});
_dropScope.PreviewDragEnter += previewHandler;
_dropScope.PreviewDragOver += previewHandler;
_adorner = new DragAdorner(_dropScope, item, true, 0.5, mouseEvent.GetPosition(item));
_layer = AdornerLayer.GetAdornerLayer(_dropScope as Visual);
_layer.Add(_adorner);
_IsDragging = true;
if (taxon != null && !string.IsNullOrWhiteSpace(taxon.TaxaFullName)) {
DataObject data = new DataObject("Taxon", taxon);
data.SetData(PinnableObject.DRAG_FORMAT_NAME, Owner.CreatePinnableTaxon(taxon.TaxaID.Value));
data.SetData(DataFormats.Text, taxon.TaxaFullName);
data.SetData(DataFormats.UnicodeText, taxon.TaxaFullName);
data.SetData(DataFormats.StringFormat, taxon.TaxaFullName);
if (!IsUnlocked) {
lblHeader.Visibility = Visibility.Visible;
}
// Actually kick off the drag drop here!
DragDropEffects de = DragDrop.DoDragDrop(item, data, DragDropEffects.Move | DragDropEffects.Copy | DragDropEffects.Link );
}
_dropScope.AllowDrop = previousDrop;
AdornerLayer.GetAdornerLayer(_dropScope).Remove(_adorner);
_adorner = null;
_dropScope.DragLeave -= dragleavehandler;
_dropScope.QueryContinueDrag -= queryhandler;
_dropScope.PreviewDragOver -= draghandler;
_dropScope.Drop -= drophandler;
_dropScope.PreviewDragEnter -= previewHandler;
_dropScope.PreviewDragOver -= previewHandler;
_IsDragging = false;
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");
//TODO: Add log here
}
if(queryContinueDrag != null)
this._dragSource.QueryContinueDrag -= queryContinueDrag;
if(giveFeedback != null)
this._dragSource.GiveFeedback -= giveFeedback;
return resultEffects;
}
public static void RemovePreviewQueryContinueDragHandler(DependencyObject element, QueryContinueDragEventHandler handler)
{
}
