public void Receive(DependencyObject value)
{
var control = (UIElement) value;
control.AllowDrop = true;
var window = Window.GetWindow(value);
DragAdorner adorner=null;
var createAdorner = Observable.FromEventPattern<DragEventHandler, DragEventArgs>
(h => control.PreviewDragEnter += h, h => control.PreviewDragEnter -= h)
.Select(ev => ev.EventArgs)
.Subscribe(e =>
{
var files = (string[])e.Data.GetData(DataFormats.FileDrop);
var container = new FileDropContainer(files);
var contentPresenter = new ContentPresenter {Content = container};
adorner = new DragAdorner(control, contentPresenter);
});
var clearAdorner = Observable.FromEventPattern<DragEventHandler, DragEventArgs>(h => control.PreviewDragLeave += h, h => control.PreviewDragLeave -= h).ToUnit()
.Merge(Observable.FromEventPattern<DragEventHandler, DragEventArgs>(h => control.PreviewDrop += h, h => control.PreviewDrop -= h).ToUnit())
.Subscribe(e =>
{
if (adorner == null) return;
adorner.Detatch();
adorner = null;
});
var updatePositionOfAdornment = Observable.FromEventPattern<DragEventHandler, DragEventArgs>
(h => control.PreviewDragOver += h, h => control.PreviewDragOver -= h)
.Select(ev => ev.EventArgs)
.Where(_=>adorner!=null)
.Subscribe(e => adorner.MousePosition = e.GetPosition(window));
var dropped = Observable.FromEventPattern<DragEventHandler, DragEventArgs>
(h => control.Drop += h, h => control.Drop -= h)
.Select(ev => ev.EventArgs)
.SelectMany(e =>
{
if (!e.Data.GetDataPresent(DataFormats.FileDrop))
return Enumerable.Empty<FileInfo>();
// Note that you can have more than one file.
var files = (string[]) e.Data.GetData(DataFormats.FileDrop);
return files.Select(f => new FileInfo(f));
})
.SubscribeSafe(_fileDropped);
_cleanUp.Disposable = Disposable.Create(() =>
{
updatePositionOfAdornment.Dispose();
clearAdorner.Dispose();
createAdorner.Dispose();
dropped.Dispose();
_fileDropped.OnCompleted();
});
}
private void InitializeDragAdorner(UIElement itemsControl, object dragData, Point startPosition)
{
if (DataTemplate == null)
{
return;
}
if (_myDragAdorner != null)
{
return;
}
var adornerLayer = AdornerLayer.GetAdornerLayer(itemsControl);
if (adornerLayer == null)
{
return;
}
_myDragAdorner = new DragAdorner(dragData, DataTemplate, itemsControl, adornerLayer);
_myDragAdorner.UpdatePosition(startPosition.X, startPosition.Y);
}
AdornerLayer InitializeAdornerLayer(ListViewItem itemToDrag)
{
// Create a brush which will paint the ListViewItem onto
// a visual in the adorner layer.
VisualBrush brush = new VisualBrush(itemToDrag);
// Create an element which displays the source item while it is dragged.
this.dragAdorner = new DragAdorner(this.listView, itemToDrag.RenderSize, brush);
// Set the drag adorner's opacity.
this.dragAdorner.Opacity = this.DragAdornerOpacity;
AdornerLayer layer = AdornerLayer.GetAdornerLayer(this.listView);
layer.Add(dragAdorner);
// Save the location of the cursor when the left mouse button was pressed.
this.ptMouseDown = MouseUtilities.GetMousePosition(this.listView);
return(layer);
}
private void selectionBeginDrag(MouseEventArgs e)
{
//ListView listView = this.listbox;
//ListViewItem listViewItem =
// FindAncestorOrSelf<ListViewItem>((DependencyObject)e.OriginalSource);
ListView listView = this.selectionlistbox;
ListViewItem listViewItem =
FindAncestorOrSelf <ListViewItem>((DependencyObject)e.OriginalSource);
if (listViewItem == null)
{
return;
}
// get the data for the ListViewItem
ImageEntry name = (ImageEntry)selectionlistbox.ItemContainerGenerator.ItemFromContainer(listViewItem);
//setup the drag adorner.
selectionInitialiseAdorner(listViewItem);
//add handles to update the adorner.
fileslistbox.PreviewDragOver += selectionListViewDragOver;
fileslistbox.DragLeave += selectionListViewDragLeave;
fileslistbox.DragEnter += selectionListViewDragEnter;
DataObject data = new DataObject("myFormat", name);
DragDropEffects de = DragDrop.DoDragDrop(this.fileslistbox, data, DragDropEffects.Move);
//cleanup
fileslistbox.PreviewDragOver -= selectionListViewDragOver;
fileslistbox.DragLeave -= selectionListViewDragLeave;
fileslistbox.DragEnter -= selectionListViewDragEnter;
if (_adorner != null)
{
AdornerLayer.GetAdornerLayer(listView).Remove(_adorner);
_adorner = null;
}
}
private void StartDragTextBlock(object sender, MouseButtonEventArgs e)
{
TextBlock tb = (TextBlock)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)tb, true, 0.5);
_layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
_layer.Add(_adorner);
IsDragging = true;
_dragHasLeftScope = false;
String content = tb.Tag.ToString();
DataObject data = new DataObject(System.Windows.DataFormats.Text.ToString(), content);
DragDropEffects de = DragDrop.DoDragDrop(tb, 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 override IScriptCommand Execute(ParameterDic pm)
{
DragAdorner dragAdorner = pm.GetValue <DragAdorner>(AdornerKey);
DragDropEffectsEx supportedEffects = pm.GetValue <DragDropEffectsEx>(SupportedEffectsKey, DragDropEffectsEx.All);
DragDropEffectsEx defaultEffect = pm.GetValue <DragDropEffectsEx>(DefaultEffectKey, DragDropEffectsEx.Copy);
RoutedEventHandler ContextMenu_Closed = null;
ContextMenu_Closed = (o, e) =>
{
dragAdorner.ContextMenu.RemoveHandler(ContextMenu.ClosedEvent, ContextMenu_Closed);
pm.SetValue(ResultEffectKey, dragAdorner.DragDropEffect);
ScriptRunner.RunScriptAsync(pm, OnCloseCommand);
};
dragAdorner.SetSupportedDragDropEffects(supportedEffects, defaultEffect);
dragAdorner.ContextMenu.AddHandler(ContextMenu.ClosedEvent, ContextMenu_Closed);
dragAdorner.ContextMenu.IsOpen = true;
return(NextCommand);
}
private void treeView_PreviewMouseMove(object sender, MouseEventArgs e)
{
var item = (Item)treeView.SelectedItem;
if (item != null && item is InstanceItem && item != NoneItem && e.LeftButton == MouseButtonState.Pressed)
{
Vector offset = e.GetPosition(null) - dragStart;
// Start drag if mouse was held for a minimum distance
if (Math.Abs(offset.X) > SystemParameters.MinimumHorizontalDragDistance ||
Math.Abs(offset.Y) > SystemParameters.MinimumVerticalDragDistance)
{
// Allow dropping anywhere within the window
Window mainWindow = Application.Current.MainWindow;
mainWindow.AllowDrop = true;
// Create item ghost
var template = new DataTemplate(typeof(InstanceItem));
var textBlock = new FrameworkElementFactory(typeof(TextBlock));
textBlock.SetBinding(TextBlock.TextProperty, new Binding("DisplayName"));
template.VisualTree = textBlock;
var adornedElement = (UIElement)mainWindow.Content;
var adornerLayer = AdornerLayer.GetAdornerLayer(adornedElement);
dragAdorner = new DragAdorner(item, template, adornedElement, adornerLayer);
mainWindow.PreviewDragOver += MainWindow_PreviewDragOver;
// Perform drag and drop
DataObject data = new DataObject(typeof(InstanceItem), item);
DragDrop.DoDragDrop(treeView, data, DragDropEffects.Move);
// Cleanup handlers
mainWindow.PreviewDragOver -= MainWindow_PreviewDragOver;
dragAdorner.Detach();
mainWindow.AllowDrop = false;
}
}
}
private AdornerLayer InitializeAdornerLayer(ListViewItem itemToDrag)
{
// Create a brush which will paint the ListViewItem onto
// a visual in the adorner layer.
var brush = new VisualBrush(itemToDrag);
// Create an element which displays the source item while it is dragged.
// ReSharper disable UseObjectOrCollectionInitializer
dragAdorner = new DragAdorner(listView, itemToDrag.RenderSize, brush);
// ReSharper restore UseObjectOrCollectionInitializer
// Set the drag adorner's opacity.
dragAdorner.Opacity = DragAdornerOpacity;
AdornerLayer layer = AdornerLayer.GetAdornerLayer(listView);
layer.Add(dragAdorner);
// Save the location of the cursor when the left mouse button was pressed.
ptMouseDown = MouseUtilities.GetMousePosition(listView);
return(layer);
}
private static void UpdateDragAdorner(IDropInfo dropInfo, DragEventArgs e)
{
if (dropInfo.Effects == DragDropEffects.None)
{
DragAdorner = null;
return;
}
if (DragAdorner == null && _dragInfo != null)
{
var sourceElement = e.Source as UIElement;
CreateDragAdorner(sourceElement);
}
if (DragAdorner == null)
{
return;
}
DragAdorner.MousePosition = e.GetPosition(DragAdorner.AdornedElement);
DragAdorner.InvalidateVisual();
}
void FinishDragOperation(ListViewItem draggedItem, AdornerLayer adornerLayer, bool isDragFullyFinished)
{
// Let the ListViewItem know that it is not being dragged anymore.
ListViewItemDragState.SetIsBeingDragged(draggedItem, false);
this.IsDragInProgress = false;
if (this.ItemUnderDragCursor != null)
{
this.ItemUnderDragCursor = null;
}
// Remove the drag adorner from the adorner layer.
if (adornerLayer != null)
{
adornerLayer.Remove(this.dragAdorner);
this.dragAdorner = null;
}
if (IsDeleteSourceItem && isDragFullyFinished && this.listView.ItemsSource is ObservableCollection <ItemType> collection)
{
collection.RemoveAt(this.listView.SelectedIndex);
}
}
private void listBoxItem_PreviewMouseMove(object sender, MouseEventArgs e)
{
var lbi = sender as ListBoxItem;
if (e.LeftButton == MouseButtonState.Pressed && dragGhost == null && dragItem == lbi)
{
var nowPos = e.GetPosition(lbi);
if (Math.Abs(nowPos.X - dragStartPos.X) > SystemParameters.MinimumHorizontalDragDistance ||
Math.Abs(nowPos.Y - dragStartPos.Y) > SystemParameters.MinimumVerticalDragDistance)
{
ItemList.AllowDrop = true;
var layer = AdornerLayer.GetAdornerLayer(ItemList);
dragGhost = new DragAdorner(ItemList, lbi, 0.5, dragStartPos);
layer.Add(dragGhost);
DragDrop.DoDragDrop(lbi, lbi, DragDropEffects.Move);
layer.Remove(dragGhost);
dragGhost = null;
dragItem = null;
ItemList.AllowDrop = false;
}
}
}
private void AddReceiveNotifycationCallBack(AddReceiveInfo info)
{
//清理工作
AdornerLayer.GetAdornerLayer(this._dragScope).Remove(this._adorner);
this._adorner = null;
this._dragScope.MouseMove -= draghandler;
_isMouseLeftButtonDown = 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();
}
private void DisposeAdorner()
{
_isDragging = false;
_dragAdorner?.Dispose();
_dragAdorner = null;
}
public static void SetDragAdorner(DependencyObject obj, DragAdorner value)
{
obj.SetValue(DragAdornerProperty, value);
}
private static void StartDrag(DependencyObject source)
{
var dragScope = Application.Current.MainWindow as FrameworkElement;
//var dragScope = Application.Current.MainWindow.Content as FrameworkElement;
dragScope.AllowDrop = true;
SetIsDragging(source, true);
DataObject dataObject = new DataObject();
var data = GetDragData(source);
dataObject.SetData(data);
var adorner = new DragAdorner(source as UIElement, data, true, 1);
var layer = AdornerLayer.GetAdornerLayer(((Window)dragScope).Content as FrameworkElement);
layer.Add(adorner);
var startPoint = (Point)source.GetValue(StartPointProperty);
adorner.UpdatePosition(startPoint);
//var adjustPoint = GetAdjustPoint(source);
//adorner.UpdatePosition(adjustPoint);
dragScope.DragOver += (sender, e) =>
{
if (adorner != null)
{
adorner.UpdatePosition(e.GetPosition(dragScope));
}
};
DragDrop.DoDragDrop(source, dataObject, DragDropEffects.Move);
layer.Remove(adorner);
adorner = null;
SetIsDragging(source, false);
}
/// <summary>
/// Stores drag data
/// </summary>
/// <param name="parent"></param>
/// <param name="data"></param>
/// <param name="adorner"></param>
internal DragData(DateButton parent, object data, DragAdorner adorner)
{
Parent = parent;
Data = data;
Adorner = adorner;
}
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;
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;
}
private static void ItemsControl_PreviewMouseMove(object sender, System.Windows.Input.MouseEventArgs e)
{
if (sender is ItemsControl itemsControl)
{
DragStatusEnum dragStatus = GetDragStatus(itemsControl);
switch (dragStatus)
{
case DragStatusEnum.None:
break;
case DragStatusEnum.Begining:
{
if (e.LeftButton == System.Windows.Input.MouseButtonState.Pressed)
{
Vector vector = e.GetPosition(itemsControl) - mouseDownPoint;
if (vector.X > dragBeginedOffset || vector.Y > dragBeginedOffset)
{
SetDragStatus(itemsControl, DragStatusEnum.Draging);
if (dragInfo.ItemContainer is FrameworkElement frameworkElement)
{
frameworkElement.CaptureMouse();
if (dragAdorner != null)
{
dragAdorner.Detath();
}
Point offset = e.GetPosition(frameworkElement);
dragAdorner = new DragAdorner(itemsControl, frameworkElement, new Point()
{
X = -offset.X, Y = -offset.Y
});
}
}
}
}
break;
case DragStatusEnum.Draging:
{
if (e.LeftButton == System.Windows.Input.MouseButtonState.Pressed)
{
if (dragAdorner != null)
{
dragAdorner.UpdatePoint(e.GetPosition(itemsControl));
}
if (GetItem(itemsControl.ItemContainerGenerator, itemsControl.InputHitTest(e.GetPosition(itemsControl)), out DependencyObject itemContainer, out object item))
{
if (/*itemContainer != dragInfo.ItemContainer && */ itemContainer is FrameworkElement frameworkElement)
{
if (lineAdorner == null)
{
lineAdorner = new LineAdorner(itemsControl);
lineAdorner.UpdateBrush(GetDropTargetLineBrush(itemsControl), GetDropTargetLineThickness(itemsControl));
lineAdorner.UpdateTarget(e.MouseDevice, frameworkElement, GetItemPanelOrientation(itemsControl));
}
else
{
lineAdorner.UpdateTarget(e.MouseDevice, frameworkElement, GetItemPanelOrientation(itemsControl));
}
}
}
else
{
if (lineAdorner != null)
{
lineAdorner.ClearTarget();
}
}
e.Handled = true;
}
}
break;
static void CreateDragAdorner()
{
DataTemplate template = GetDragAdornerTemplate(m_DragInfo.VisualSource);
if (template != null)
{
UIElement rootElement = (UIElement)Application.Current.MainWindow.Content;
UIElement adornment = null;
if (m_DragInfo.Data is IEnumerable && !(m_DragInfo.Data is string))
{
if (((IEnumerable)m_DragInfo.Data).Cast<object>().Count() <= 10)
{
ItemsControl itemsControl = new ItemsControl();
itemsControl.ItemsSource = (IEnumerable)m_DragInfo.Data;
itemsControl.ItemTemplate = template;
// The ItemsControl doesn't display unless we create a border to contain it.
// Not quite sure why this is...
Border border = new Border();
border.Child = itemsControl;
adornment = border;
}
}
else
{
ContentPresenter contentPresenter = new ContentPresenter();
contentPresenter.Content = m_DragInfo.Data;
contentPresenter.ContentTemplate = template;
adornment = contentPresenter;
}
if (adornment != null)
{
adornment.Opacity = 0.5;
DragAdorner = new DragAdorner(rootElement, adornment);
}
}
}
private void AttachToVisualTree()
{
// detach from the old tree
this.DetachFromVisualTree();
// create the drag adorner for selection operations
_dragAdorner = new DragAdorner( this );
// check the template for a SelectionBrush resource
if( this.Template.Resources.Contains( "SelectionBrush" ) )
_dragAdorner.Brush = this.Template.Resources[ "SelectionBrush" ] as Brush;
// check the template for a SelectionPen resource
if( this.Template.Resources.Contains( "SelectionPen" ) )
_dragAdorner.Pen = this.Template.Resources[ "SelectionPen" ] as Pen;
// check the template for key bindings
if( this.Template.Resources.Contains( "InputBindings" ) )
{
InputBindingCollection inputBindings = this.Template.Resources[ "InputBindings" ] as InputBindingCollection;
if( inputBindings != null )
{
this.InputBindings.AddRange( inputBindings );
}
}
// locate the content presenter
_contentPresenter = VisualTreeHelperEx.FindDescendantByType( this, typeof( ContentPresenter ) ) as ContentPresenter;
if( _contentPresenter == null )
throw new InvalidTemplateException( ErrorMessages.GetMessage( "ZoomboxTemplateNeedsContent" ) );
//locate the vertical scrollBar
if( _verticalScrollBar != null )
{
_verticalScrollBar.Scroll -= this.VerticalScrollBar_Scroll;
}
_verticalScrollBar = this.GetTemplateChild( PART_VerticalScrollBar ) as ScrollBar;
if( _verticalScrollBar == null )
throw new InvalidTemplateException( ErrorMessages.GetMessage( "Zoombox vertical scrollBar not found." ) );
_verticalScrollBar.Scroll += this.VerticalScrollBar_Scroll;
//locate the horizontal scrollBar
if( _horizontalScrollBar != null )
{
_horizontalScrollBar.Scroll -= this.HorizontalScrollBar_Scroll;
}
_horizontalScrollBar = this.GetTemplateChild( PART_HorizontalScrollBar ) as ScrollBar;
if( _horizontalScrollBar == null )
throw new InvalidTemplateException( ErrorMessages.GetMessage( "Zoombox horizontal scrollBar not found." ) );
_horizontalScrollBar.Scroll += this.HorizontalScrollBar_Scroll;
// check the template for an AdornerDecorator
AdornerLayer al = null;
AdornerDecorator ad = VisualTreeHelperEx.FindDescendantByType( this, typeof( AdornerDecorator ) ) as AdornerDecorator;
if( ad != null )
{
al = ad.AdornerLayer;
}
else
{
// look for an inherited adorner layer
try
{
al = AdornerLayer.GetAdornerLayer( this );
}
catch( Exception )
{
}
}
// add the drag adorner to the adorner layer
if( al != null )
{
al.Add( _dragAdorner );
}
// TODO: Why is it necessary to walk the visual tree the first time through?
// If we don't do the following, the content is not laid out correctly (centered) initially.
VisualTreeHelperEx.FindDescendantWithPropertyValue( this, Button.IsPressedProperty, true );
// set a reference to the ViewFinder element, if present
this.SetValue( Zoombox.ViewFinderPropertyKey, this.Template.FindName( "ViewFinder", this ) as FrameworkElement );
// locate the view finder display panel
_viewFinderDisplay = VisualTreeHelperEx.FindDescendantByType( this, typeof( ZoomboxViewFinderDisplay ) ) as ZoomboxViewFinderDisplay;
// if a ViewFinder was specified but no display panel is present, throw an exception
if( this.ViewFinder != null && _viewFinderDisplay == null )
throw new InvalidTemplateException( ErrorMessages.GetMessage( "ZoomboxHasViewFinderButNotDisplay" ) );
// set up the VisualBrush and adorner for the display panel
if( _viewFinderDisplay != null )
{
// create VisualBrush for the view finder display panel
this.CreateVisualBrushForViewFinder( _content );
// hook up event handlers for dragging and resizing the viewport
_viewFinderDisplay.MouseMove += new MouseEventHandler( this.ViewFinderDisplayMouseMove );
_viewFinderDisplay.MouseLeftButtonDown += new MouseButtonEventHandler( this.ViewFinderDisplayBeginCapture );
_viewFinderDisplay.MouseLeftButtonUp += new MouseButtonEventHandler( this.ViewFinderDisplayEndCapture );
// bind the ViewportRect property of the display to the Viewport of the Zoombox
Binding binding = new Binding( "Viewport" );
binding.Mode = BindingMode.OneWay;
binding.Converter = new ViewFinderSelectionConverter( this );
binding.Source = this;
_viewFinderDisplay.SetBinding( ZoomboxViewFinderDisplay.ViewportRectProperty, binding );
}
// set up event handler to run once the content presenter has been arranged
_contentPresenter.LayoutUpdated += new EventHandler( this.ContentPresenterFirstArranged );
}
private void OnAddScanner(ScreenPropertyPanel panel)
{
ScreenRealParams.ScreenLayer.CLineType = ConnectLineType.Auto;
int cols = AddColsCount;
int rows = AddRowsCount;
ScanBoardProperty scanBdProp = SelectedScannerConfig.ScanBdProp;
int width = scanBdProp.Width;
int height = scanBdProp.Height;
_isMouseLeftButtonDown = true;
//拖动的区域
this._dragScope = Application.Current.Windows[Application.Current.Windows.Count-1].Content as FrameworkElement;
//是否可以拖放
this._dragScope.AllowDrop = true;
draghandler = new MouseEventHandler(DragScope_PreviewDragOver);
//加载处理拖放的路由事件
this._dragScope.MouseMove += draghandler;
//鼠标跟随效果的装饰器
Point mousePoint = new Point();
mousePoint = Mouse.GetPosition(this._dragScope);
this._adorner = new DragAdorner(this._dragScope, width * Math.Pow(SmartLCTViewModeBase.IncreaseOrDecreaseValue, IncreaseOrDecreaseIndex), height * Math.Pow(SmartLCTViewModeBase.IncreaseOrDecreaseValue, IncreaseOrDecreaseIndex), rows, cols, mousePoint, 0.5);
this._adorner.LeftOffset = mousePoint.X;
this._adorner.TopOffset = mousePoint.Y;
this._layer = AdornerLayer.GetAdornerLayer(this._dragScope as Visual);
this._layer.Add(this._adorner);
NotificationMessageAction<AddReceiveInfo> nsa =
new NotificationMessageAction<AddReceiveInfo>(this, new AddReceiveInfo(rows, cols, SelectedScannerConfig), MsgToken.MSG_ADDRECEIVE, AddReceiveNotifycationCallBack);
Messenger.Default.Send(nsa, MsgToken.MSG_ADDRECEIVE);
}
private void canvas_Drop(object sender, DragEventArgs e)
{
SpaceObject so = null;
if (e.Data.GetDataPresent(typeof(SpaceObject)))
{
so = e.Data.GetData(typeof(SpaceObject)) as SpaceObject;
}
else if (e.Data.GetDataPresent(typeof(BorderAdorner)))
{
so = SelectedSpaceObject as SpaceObject;
}
else if (e.Data.GetDataPresent(typeof(GroupBox)))
{
GroupBox obj = e.Data.GetData(typeof(GroupBox)) as GroupBox;
if (obj != null)
{
UnmappableObject newObj = new UnmappableObject();
newObj.CommandName = obj.Tag as string;
AddSpaceObjectEvents(newObj);
//Need only to add delete support at this point.
CommandsAndConditions.Add(newObj);
}
}
if (so != null)
{
FrameworkElement dscope = DragHelper.GetDragScope(so);
DragAdorner adorner = null;
if (dscope != null)
{
adorner = DragHelper.GetDragAdorner(dscope);
}
bool DoAdd = false;
if (so.Tag == null)
{
SpaceObject so2 = new SpaceObject();
so2.ObjectType = so.ObjectType;
so2.Tag = "xxx";
SetSpaceObjectSize(so2);
AddSpaceObjectEvents(so2);
//so2.ObjectName = "test";
so = so2;
//so.X = Canvas.GetLeft(so);
//so.Z = Canvas.GetTop(so);
//Raise added (needs to get to Xml))
DoAdd = true;
}
if (!canvas.Children.Contains(so))
{
canvas.Children.Add(so);
}
//Point wrkP = DragHelper.GetRelativeMousePoint(so); no
Point wrkP = e.GetPosition(canvas);
if (adorner != null)
{
//wrkP = new Point(
// adorner.LeftOffset - (ItemPool.ActualWidth + gridSplit.ActualWidth) + canvasScroll.HorizontalOffset,
// adorner.TopOffset + canvasScroll.VerticalOffset);
wrkP = new Point(
adorner.LeftOffset + canvasScroll.HorizontalOffset,
adorner.TopOffset + canvasScroll.VerticalOffset);
}
so.X = wrkP.X / zoomFactor;
so.Z = wrkP.Y / zoomFactor;
Canvas.SetTop(so, wrkP.Y);
Canvas.SetLeft(so, wrkP.X);
if (DoAdd)
{
this.RaiseEvent(new RoutedEventArgs(ObjectAddedEvent, so));
}
else
{
this.RaiseEvent(new RoutedEventArgs(ObjectMovedEvent, so));
}
//this.Dispatcher.BeginInvoke(new Action<SpaceObject>(SetSpaceObjectSize), System.Windows.Threading.DispatcherPriority.Loaded, so);
}
}
public void StartDragging() {
var adorner = new DragAdorner(Shell.Content as UIElement, this);
State = ScriptBlockState.Moving;
DragDrop.DoDragDrop(this, this, DragDropEffects.All);
State = ScriptBlockState.Selected;
adorner.Close();
}
public void Receive(DependencyObject value)
{
if (_isLoaded || null == value)
{
return;
}
_isLoaded = true;
var control = value as UIElement;
if (null == control)
{
return;
}
control.AllowDrop = true;
var window = Window.GetWindow(value);
DragAdorner adorner = null;
var createAdorner = Observable.FromEventPattern <DragEventHandler, DragEventArgs>
(h => control.PreviewDragEnter += h, h => control.PreviewDragEnter -= h)
.Select(ev => ev.EventArgs)
.Subscribe(e =>
{
var files = (string[])e.Data.GetData(DataFormats.FileDrop);
var container = new FileDropContainer(files);
var contentPresenter = new ContentPresenter {
Content = container
};
adorner = new DragAdorner(control, contentPresenter);
});
var clearAdorner = Observable.FromEventPattern <DragEventHandler, DragEventArgs>(h => control.PreviewDragLeave += h, h => control.PreviewDragLeave -= h).ToUnit()
.Merge(Observable.FromEventPattern <DragEventHandler, DragEventArgs>(h => control.PreviewDrop += h, h => control.PreviewDrop -= h).ToUnit())
.Subscribe(e =>
{
if (adorner == null)
{
return;
}
adorner.Detatch();
adorner = null;
});
var updatePositionOfAdornment = Observable.FromEventPattern <DragEventHandler, DragEventArgs>
(h => control.PreviewDragOver += h, h => control.PreviewDragOver -= h)
.Select(ev => ev.EventArgs)
.Where(_ => adorner != null)
.Subscribe(e => adorner.MousePosition = e.GetPosition(window));
var dropped = Observable.FromEventPattern <DragEventHandler, DragEventArgs>
(h => control.Drop += h, h => control.Drop -= h)
.Select(ev => ev.EventArgs)
.SelectMany(e =>
{
if (!e.Data.GetDataPresent(DataFormats.FileDrop))
{
return(Enumerable.Empty <FileInfo>());
}
// Note that you can have more than one file.
var files = (string[])e.Data.GetData(DataFormats.FileDrop);
return(files.Select(f => new FileInfo(f)));
})
.SubscribeSafe(_fileDropped);
_cleanUp.Disposable = Disposable.Create(() =>
{
updatePositionOfAdornment.Dispose();
clearAdorner.Dispose();
createAdorner.Dispose();
dropped.Dispose();
_fileDropped.OnCompleted();
});
}
private void TabStackPanelPreviewMouseDown(object sender, MouseButtonEventArgs e)
{
if (EditorTabs.Count <= 1)
{
return;
}
var textBlock = e.Source as TextBlock;
if (textBlock == null)
{
return;
}
var stackPanel = textBlock.Parent as StackPanel;
if (stackPanel == null)
{
return;
}
var contentPresenter = stackPanel.TemplatedParent as ContentPresenter;
if (contentPresenter == null)
{
return;
}
_tabDragTimer = new Timer(500);
_tabDragTimer.Elapsed += (o, args) =>
{
Dispatcher.Invoke(() =>
{
if (Mouse.PrimaryDevice.LeftButton != MouseButtonState.Pressed)
{
return;
}
_tabDragTimer.Stop();
_tabDragTimer.Dispose();
_tabDragTimer = null;
_dragAdorner = new DragAdorner(TopWindowGrid, CreateScriptDragAdornerElement(textBlock.Text))
{
MousePosition = e.GetPosition(this)
};
DragOver += TopWindowGridOnDragOver;
DragDrop.DoDragDrop(contentPresenter, contentPresenter, DragDropEffects.All);
DragOver -= TopWindowGridOnDragOver;
_dragAdorner.Remove();
_dragAdorner = null;
});
};
_tabDragTimer.Start();
}
