private void Register()
{
itemsPresenter = listBox.FindVisualChildOfType <ItemsPresenter>();
if (itemsPresenter == null)
{
return;
}
var adornerLayer = AdornerLayer.GetAdornerLayer(itemsPresenter);
if (adornerLayer == null)
{
return;
}
selectionRect = new SelectionAdorner(itemsPresenter);
adornerLayer.Add(selectionRect);
selector = new ItemsControlSelector(listBox);
autoScroller = new AutoScroller(listBox);
autoScroller.OffsetChanged += OnOffsetChanged;
// The ListBox intercepts the regular MouseLeftButtonDown event
// to do its selection processing, so we need to handle the
// PreviewMouseLeftButtonDown. The scroll content won't receive
// the message if we click on a blank area so use the ListBox.
listBox.PreviewMouseLeftButtonDown += OnPreviewMouseLeftButtonDown;
listBox.MouseLeftButtonUp += OnMouseLeftButtonUp;
listBox.MouseMove += OnMouseMove;
}
private void UpdateAdorner(UIElement directlyOverElement)
{
if (_selectionAdorner != null)
{
_adornerLayer.Remove(_selectionAdorner);
}
if (directlyOverElement != null && _settings.IsShowAdorner)
{
var adornerLayer = AdornerLayer.GetAdornerLayer(directlyOverElement);
if (adornerLayer != null)
{
_adornerLayer = adornerLayer;
if (directlyOverElement is Grid)
{
_selectionAdorner = new GridAdorner(directlyOverElement);
}
else
{
_selectionAdorner = new SelectionAdorner(directlyOverElement);
}
_adornerLayer.Add(_selectionAdorner);
}
}
}
private static void OnDesignerContinueSelect(object sender,
MouseEventArgs e)
{
if (_selectedItemType != SelectedItemType.SelectItem)
{
return;
}
if (e.LeftButton != MouseButtonState.Pressed)
{
_rubberbandSelectionStartPoint = null;
}
if (_rubberbandSelectionStartPoint.HasValue)
{
var adornerLayer = AdornerLayer.GetAdornerLayer(_itemsPanel);
if (adornerLayer != null)
{
var adorner = new SelectionAdorner(_itemsPanel,
_rubberbandSelectionStartPoint,
_designerVewModel,
_designerVewModel.ItemToDraw as ISelectionItem);
adornerLayer.Add(adorner);
}
}
e.Handled = true;
}
public RegionSelectorViewModel(
[NotNull] ISelectionAdornerViewModel selectionAdorner,
[NotNull][Dependency(WellKnownSchedulers.UI)] IScheduler uiScheduler,
[NotNull][Dependency(WellKnownSchedulers.Background)] IScheduler bgScheduler)
{
SelectionAdorner = selectionAdorner.AddTo(Anchors);
windowSeeker = new TaskWindowSeeker
{
SkipNotVisibleWindows = true
};
var refreshRequest = new Subject <Unit>();
SelectionAdorner.WhenAnyValue(x => x.MousePosition, x => x.Owner).ToUnit()
.Merge(refreshRequest)
.Select(x => new { SelectionAdorner.MousePosition, SelectionAdorner.Owner })
.Where(x => x.Owner != null)
.Sample(ThrottlingPeriod, bgScheduler)
.ObserveOn(uiScheduler)
.Select(x => x.MousePosition.ToScreen(x.Owner))
.Select(x => new Rectangle(x.X, x.Y, 1, 1))
.Select(ToRegionResult)
.Do(x => Log.Debug($"Selection candidate: {x}"))
.Subscribe(x => SelectionCandidate = x)
.AddTo(Anchors);
refreshRequest
.Subscribe(() => windowSeeker.Refresh())
.AddTo(Anchors);
Observable.Timer(DateTimeOffset.Now, TimeSpan.FromSeconds(1), bgScheduler).ToUnit()
.Subscribe(refreshRequest)
.AddTo(Anchors);
}
static void UpdatePosition(ScrollContentPresenter p, bool highlightOnly)
{
ScrollViewer scrollViewer = UITools.FindAncestor <ScrollViewer>(p);
SelectionAdorner _adorner = GetSelectionAdorner(p);
if (GetIsDragging(p))
{
Point startScrollbarPosition = GetStartScrollbarPosition(p);
Point curScrollbarPosition = GetScrollbarPosition(p);
Point startPosition = GetStartPosition(p);
Point curPosition = Mouse.GetPosition(p);
if (!_adorner.IsSelecting)
{
if (Math.Abs(startPosition.X - curPosition.X) > SystemParameters.MinimumHorizontalDragDistance ||
Math.Abs(startPosition.Y - curPosition.Y) > SystemParameters.MinimumVerticalDragDistance)
{
_adorner.IsSelecting = true;
Mouse.Capture(p);
}
}
else
{
Vector offset = Point.Subtract(startScrollbarPosition, curScrollbarPosition);
_adorner.StartPosition = Point.Add(startPosition, offset);
_adorner.EndPosition = curPosition;
UpdateSelection(p, new Rect(
new Point(startPosition.X + startScrollbarPosition.X, startPosition.Y + startScrollbarPosition.Y),
new Point(curPosition.X + curScrollbarPosition.X, curPosition.Y + curScrollbarPosition.Y)), highlightOnly);
}
}
}
private bool Register()
{
this.scrollContent = FindChild <ScrollContentPresenter>(this.listBox);
if (this.scrollContent != null)
{
this.autoScroller = new AutoScroller(this.listBox);
this.autoScroller.OffsetChanged += this.OnOffsetChanged;
this.selectionRect = new SelectionAdorner(this.scrollContent);
this.scrollContent.AdornerLayer.Add(this.selectionRect);
this.selector = new ItemsControlSelector(this.listBox);
// The ListBox intercepts the regular MouseLeftButtonDown event
// to do its selection processing, so we need to handle the
// PreviewMouseLeftButtonDown. The scroll content won't receive
// the message if we click on a blank area so use the ListBox.
this.listBox.PreviewMouseLeftButtonDown += this.OnPreviewMouseLeftButtonDown;
this.listBox.MouseLeftButtonUp += this.OnMouseLeftButtonUp;
this.listBox.MouseMove += this.OnMouseMove;
}
// Return success if we found the ScrollContentPresenter
return(this.scrollContent != null);
}
static void EndDragging(ScrollContentPresenter p)
{
SelectionAdorner _adorner = GetSelectionAdorner(p);
if (_adorner.IsSelecting)
{
UpdatePosition(p, false);
_adorner.IsSelecting = false;
SetIsDragging(p, false);
}
}
private ScrollContentPresenter UpdateScrollContent()
{
scrollContent = FindChild <ScrollContentPresenter>(listBox);
if (scrollContent != null)
{
selectionRect = new SelectionAdorner(scrollContent);
scrollContent.AdornerLayer.Add(selectionRect);
}
return(scrollContent);
}
private void CreateSelectionAdorner(Point startPoint)
{
RemoveSelectionAdorner();
if (_adornerLayer == null)
{
_adornerLayer = AdornerLayer.GetAdornerLayer(_selector);
}
_selectionAdorner = new SelectionAdorner(_selector, startPoint);
_adornerLayer.Add(_selectionAdorner);
}
private void CreateAdorner(Canvas canvas, PointEx origin, PointEx point)
{
Adorner = new SelectionAdorner(canvas);
Adorner.Zoom = GetZoomScaleTransform().ScaleX;
Adorner.SelectionOrigin = new Point(origin.X, origin.Y);
Adorner.SelectionRect = new RectEx(origin.X, origin.Y, point.X, point.Y);
Adorner.SnapsToDevicePixels = false;
RenderOptions.SetEdgeMode(Adorner, EdgeMode.Aliased);
AdornerLayer.GetAdornerLayer(canvas).Add(Adorner);
Adorner.InvalidateVisual();
}
internal static object PositionCheck(DependencyObject sender, object value)
{
if (value is Point)
{
Point ptValue = (Point)value;
SelectionAdorner adorner = sender as SelectionAdorner;
ptValue.X = Math.Max(ptValue.X, 0);
ptValue.X = Math.Min(ptValue.X, adorner.ActualWidth);
ptValue.Y = Math.Max(ptValue.Y, 0);
ptValue.Y = Math.Min(ptValue.Y, adorner.ActualHeight);
return(ptValue);
}
return(value);
}
private void SelectElement(FrameworkElement element)
{
if (_overlayElement != null)
{
AdornerLayer.GetAdornerLayer(_overlayElement.AdornedElement)?.Remove(_overlayElement);
}
if (element != null)
{
_overlayElement = new SelectionAdorner(element);
_overlayElement.MouseLeftButtonDown += OverlayElementMouseLeftButtonDown;
AdornerLayer.GetAdornerLayer(element)?.Add(_overlayElement);
}
else
{
_overlayElement = null;
}
}
private void RemoveSelectionAdorner()
{
if (_adornerLayer == null)
{
return;
}
if (_selectionAdorner == null)
{
return;
}
_selectionAdorner.EndPoint = null;
_adornerLayer.Remove(_selectionAdorner);
_selectionAdorner = null;
_adornerLayer = null;
}
private void InitializePathAdorner(SelectionAdorner adorner, Geometry geometry)
{
adorner.Outline = geometry;
adorner.Visibility = Visibility.Visible;
}
private void ResetPathAdorner(SelectionAdorner adorner)
{
adorner.Outline = (Geometry)null;
adorner.Visibility = Visibility.Collapsed;
}
private void RemoveAdorner(Canvas canvas)
{
AdornerLayer.GetAdornerLayer(canvas).Remove(Adorner);
Adorner = null;
}
protected override Script.IScriptCommand executeInner(ParameterDic pm, ItemsControl sender,
RoutedEventArgs evnt, IUIInput input, IList <IUIInputProcessor> inpProcs)
{
var scp = ControlUtils.GetScrollContentPresenter(sender);
if (scp != null)
{
AdornerLayer adornerLayer = ControlUtils.GetAdornerLayer(sender);
switch (AdornerMode)
{
case UIEventHub.AdornerMode.Attach:
if (adornerLayer == null)
{
return(ResultCommand.Error(new Exception("Adorner layer not found.")));
}
if (UIEventHubProperties.GetSelectionAdorner(scp) == null)
{
Window parentWindow = UITools.FindAncestor <Window>(sender);
Point scpPos = scp.TranslatePoint(new Point(0, 0), sender);
//Create and register adorner.
SelectionAdorner adorner = new SelectionAdorner(scp)
{
//AdjustVector = new Vector(-scpPos.X, -scpPos.Y)
};
pm.SetValue(SelectionAdornerKey, adorner);
UIEventHubProperties.SetSelectionAdorner(scp, adorner);
UIEventHubProperties.SetLastScrollContentPresenter(sender, scp); //For used when detach.
adornerLayer.Add(adorner);
}
break;
case UIEventHub.AdornerMode.Detach:
var lastScp = UIEventHubProperties.GetLastScrollContentPresenter(sender); //For used when detach.
var lastAdorner = UIEventHubProperties.GetSelectionAdorner(scp);
if (lastAdorner != null)
{
adornerLayer.Remove(lastAdorner);
}
UIEventHubProperties.SetLastScrollContentPresenter(sender, null);
UIEventHubProperties.SetSelectionAdorner(scp, null);
pm.SetValue <Object>(SelectionAdornerKey, null);
break;
case UIEventHub.AdornerMode.Update:
var updateAdorner = pm.GetValue <SelectionAdorner>(SelectionAdornerKey) ??
UIEventHubProperties.GetSelectionAdorner(scp);
if (updateAdorner == null)
{
return(ResultCommand.Error(new Exception("Adorner not found.")));
}
updateAdorner.IsSelecting = UIEventHubProperties.GetIsSelecting(sender);
Point startAdjusted = pm.GetValue <Point>("{StartPosition}");
Point current = pm.GetValue <Point>(CurrentPositionKey);
updateAdorner.SetValue(SelectionAdorner.StartPositionProperty, startAdjusted);
updateAdorner.SetValue(SelectionAdorner.EndPositionProperty, current);
break;
}
}
return(NextCommand);
}
private void InitializePathAdorner(SelectionAdorner adorner, Geometry geometry)
{
adorner.Outline = geometry;
adorner.Visibility = Visibility.Visible;
}
public static void SetSelectionAdorner(DependencyObject target, SelectionAdorner value)
{
target.SetValue(SelectionAdornerProperty, value);
}
private void ResetPathAdorner(SelectionAdorner adorner)
{
adorner.Outline = (Geometry)null;
adorner.Visibility = Visibility.Collapsed;
}
public static void OnEnableSelectionpChanged(DependencyObject s, DependencyPropertyChangedEventArgs e)
{
if (s is ListView)
{
ListView control = s as ListView;
var OnSizeChanged = (RoutedEventHandler) delegate(object sender, RoutedEventArgs args)
{
ItemsPresenter ip = UITools.FindVisualChild <ItemsPresenter>(sender as ListView);
ScrollContentPresenter p = UITools.FindAncestor <ScrollContentPresenter>(ip);
EndDragging(p);
};
Func <ScrollContentPresenter, AdornerLayer> getAdornerLayer = (p) =>
{
AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(p);
if (adornerLayer != null)
{
return(adornerLayer);
}
ItemsPresenter ip = UITools.FindVisualChild <ItemsPresenter>(s as ListView);
AdornerDecorator ad = UITools.FindAncestor <AdornerDecorator>(ip);
try
{
adornerLayer = AdornerLayer.GetAdornerLayer(ad);
if (adornerLayer != null)
{
return(adornerLayer);
}
}
catch { }
return(p.AdornerLayer);;
};
Action unloadAdorner = () =>
{
ScrollContentPresenter p = GetLastScrollContentPresenter(control);
if (p != null)
{
SelectionAdorner _adorner = GetSelectionAdorner(p);
if (_adorner != null)
{
getAdornerLayer(p).Remove(_adorner);
_adorner.PreviewMouseDown -= new MouseButtonEventHandler(OnPreviewMouseDown);
_adorner.MouseMove -= new MouseEventHandler(OnMouseMove);
_adorner.MouseUp -= new MouseButtonEventHandler(OnMouseUp);
}
control.MouseUp -= new MouseButtonEventHandler(OnMouseUp);
control.MouseMove -= new MouseEventHandler(OnMouseMove);
control.RemoveHandler(ListView.SizeChangedEvent, OnSizeChanged);
SetSelectionAdorner(p, null);
}
};
Action attachAdorner = () =>
{
unloadAdorner();
ItemsPresenter ip = UITools.FindVisualChild <ItemsPresenter>(control);
ScrollContentPresenter p = UITools.FindAncestor <ScrollContentPresenter>(ip);
if (p != null)
{
SelectionAdorner _adorner = new SelectionAdorner(p);
SetSelectionAdorner(p, _adorner);
AdornerLayer adornerLayer = getAdornerLayer(p);
if (adornerLayer != null)
{
adornerLayer.Add(_adorner);
_adorner.PreviewMouseDown += new MouseButtonEventHandler(OnPreviewMouseDown);
_adorner.MouseMove += new MouseEventHandler(OnMouseMove);
_adorner.MouseUp += new MouseButtonEventHandler(OnMouseUp);
}
control.PreviewMouseDown += new MouseButtonEventHandler(OnPreviewMouseDown);
control.MouseUp += new MouseButtonEventHandler(OnMouseUp);
control.MouseMove += new MouseEventHandler(OnMouseMove);
control.AddHandler(ListView.SizeChangedEvent, OnSizeChanged);
SetLastScrollContentPresenter(control, p);
}
};
if ((bool)e.NewValue == true)
{
if (control.IsLoaded)
{
attachAdorner();
}
else
{
control.Loaded += delegate { attachAdorner(); }
};
control.AddHandler(ScrollViewer.ScrollChangedEvent, new RoutedEventHandler(OnScrollChange));
control.AddHandler(ListView.MouseDownEvent, new RoutedEventHandler(OnMouseDown));
//Monitor view change, and reattach handlers.
DependencyPropertyDescriptor viewDescriptor = DependencyPropertyDescriptor.FromProperty(ListView.ViewProperty, typeof(ListView));
viewDescriptor.AddValueChanged
(control, delegate
{
control.Dispatcher.BeginInvoke(DispatcherPriority.Input, attachAdorner);
});
}
else //If EnableSelection = False
{
unloadAdorner();
control.RemoveHandler(ScrollViewer.ScrollChangedEvent, new RoutedEventHandler(OnScrollChange));
control.RemoveHandler(ListView.MouseDownEvent, new RoutedEventHandler(OnMouseDown));
SetSelectionAdorner(control, null);
}
}
}
