private static Keys[] GetKeys(IInputElement focusElement)
{
// the buffer must be exactly 256 bytes long as per API definition
var keyStates = new byte[256];
if (!NativeGetKeyboardState(keyStates))
throw new Win32Exception(Marshal.GetLastWin32Error());
var pressedKeys = new List<Keys>();
if (focusElement.IsKeyboardFocused)
{
// skip the first 8 entries as they are actually mouse events and not keyboard keys
const int skipMouseKeys = 8;
for (int i = skipMouseKeys; i < keyStates.Length; i++)
{
byte key = keyStates[i];
//Logical 'and' so we can drop the low-order bit for toggled keys, else that key will appear with the value 1!
if ((key & 0x80) != 0)
{
//This is just for a short demo, you may want this to return
//multiple keys!
if (key != 0)
pressedKeys.Add((Keys)i);
}
}
}
return pressedKeys.ToArray();
}
/// <summary>
/// Creates a new instance of the keyboard helper.
/// </summary>
/// <param name="focusElement">The element that will be used as the focus point. Provide your implementation of <see cref="WpfGame"/> here.</param>
public WpfKeyboard(IInputElement focusElement)
{
if (focusElement == null)
throw new ArgumentNullException(nameof(focusElement));
_focusElement = focusElement;
}
public override TouchPointCollection GetIntermediateTouchPoints(IInputElement relativeTo)
{
TouchPointCollection collection = new TouchPointCollection();
UIElement element = relativeTo as UIElement;
if (element == null)
return collection;
foreach (HandPointEventArgs e in intermediateEvents)
{
Point point = screen.MapPositionToScreen(e.Session);
if (relativeTo != null)
{
point = this.ActiveSource.RootVisual.TransformToDescendant((Visual)relativeTo).Transform(point);
}
//Rect rect = e.BoundingRect;
Rect rect = new Rect(screen.MapPositionToScreen(e.Session),
new Size(1, 1));
TouchAction action = TouchAction.Move;
if (lastEventArgs.Status == HandPointStatus.Down)
{
action = TouchAction.Down;
}
else if (lastEventArgs.Status == HandPointStatus.Up)
{
action = TouchAction.Up;
}
collection.Add(new TouchPoint(this, point, rect, action));
}
return collection;
}
/// <summary>
/// 提交树型表格内部某元素引发的修改。
/// </summary>
public static void ExecuteCommitEdit(IInputElement target)
{
if (TreeGrid.CommitEditCommand.CanExecute(null, target))
{
TreeGrid.CommitEditCommand.Execute(null, target);
}
}
public static bool TryFindFocusedControl(IInputElement focusedElement, out DataEntryControl focusedControl)
{
if (focusedElement is FrameworkElement)
{
FrameworkElement focusedFrameworkElement = (FrameworkElement)focusedElement;
focusedControl = (DataEntryControl)focusedFrameworkElement.Tag;
if (focusedControl != null)
{
return true;
}
// for complex controls which dynamic generate child controls, such as date time pickers, the tag of the focused element can't be set
// so try to locate a parent of the focused element with a tag indicating the control
FrameworkElement parent = null;
if (focusedFrameworkElement.Parent != null && focusedFrameworkElement.Parent is FrameworkElement)
{
parent = (FrameworkElement)focusedFrameworkElement.Parent;
}
else if (focusedFrameworkElement.TemplatedParent != null && focusedFrameworkElement.TemplatedParent is FrameworkElement)
{
parent = (FrameworkElement)focusedFrameworkElement.TemplatedParent;
}
if (parent != null)
{
return DataEntryHandler.TryFindFocusedControl(parent, out focusedControl);
}
}
focusedControl = null;
return false;
}
public void Focus(IInputElement element) {
Debug.Assert(element != null && element.Focusable);
if (element == null || !element.Focusable)
return;
if (CanFocus)
element.Focus();
}
public void SetFocusedElement(
IInputElement element,
NavigationMethod method,
InputModifiers modifiers)
{
if (element != FocusedElement)
{
var interactive = FocusedElement as IInteractive;
interactive?.RaiseEvent(new RoutedEventArgs
{
RoutedEvent = InputElement.LostFocusEvent,
});
FocusedElement = element;
interactive = element as IInteractive;
interactive?.RaiseEvent(new GotFocusEventArgs
{
RoutedEvent = InputElement.GotFocusEvent,
NavigationMethod = method,
InputModifiers = modifiers,
});
}
}
public bool Capture(Contact contact, IInputElement element, CaptureMode captureMode)
{
if(element == null)
captureMode = CaptureMode.None;
if(captureMode == CaptureMode.None)
element = null;
DependencyObject oldCaptured = contact.InputArgs.Captured;
if(oldCaptured == element)
return true;
using (dispatcher.DisableProcessing())
{
long timestamp = Stopwatch.GetTimestamp();
if (contact.InputArgs.Captured != null)
RaiseCaptureEvent(contact, MultitouchScreen.LostContactCaptureEvent, contact.InputArgs.Captured, timestamp);
contact.InputArgs.Captured = (DependencyObject)element;
contact.InputArgs.CaptureState = captureMode;
if (contact.InputArgs.Captured != null)
RaiseCaptureEvent(contact, MultitouchScreen.GotContactCaptureEvent, contact.InputArgs.Captured, timestamp);
}
return true;
}
public override void ShowDialog(PropertyValue propertyValue, IInputElement commandSource)
{
OpenFileDialog dlg = new OpenFileDialog();
var filename = FileName;
if (!String.IsNullOrWhiteSpace(filename))
{
dlg.FileName = filename;
}
var dialogtitle = DialogTitle;
if (!String.IsNullOrWhiteSpace(dialogtitle))
{
dlg.Title = dialogtitle;
}
var filter = Filter;
if (!String.IsNullOrWhiteSpace(filter))
{
dlg.Filter = filter;
}
dlg.FilterIndex = 0;
dlg.Multiselect = false;
dlg.FileOk += this.BeforeFileOk;
if (dlg.ShowDialog() == true)
{
this.OnFileOk(dlg.FileName, propertyValue, commandSource);
}
}
public override void ShowDialog(PropertyValue propertyValue, IInputElement commandSource)
{
ModelPropertyEntryToOwnerActivityConverter ownerActivityConverter = new ModelPropertyEntryToOwnerActivityConverter();
ModelItem activityItem =
ownerActivityConverter.Convert(propertyValue.ParentProperty, typeof(ModelItem), false, null) as ModelItem;
EditingContext context = activityItem.GetEditingContext();
ModelItem parentModelItem =
ownerActivityConverter.Convert(propertyValue.ParentProperty, typeof(ModelItem), true, null) as ModelItem;
ModelItemDictionary arguments = parentModelItem.Properties[propertyValue.ParentProperty.PropertyName].Dictionary;
DynamicArgumentDesignerOptions options = new DynamicArgumentDesignerOptions
{
Title = propertyValue.ParentProperty.DisplayName
};
using (ModelEditingScope change = arguments.BeginEdit("PowerShellParameterEditing"))
{
if (DynamicArgumentDialog.ShowDialog(activityItem, arguments, context, activityItem.View, options))
{
change.Complete();
}
else
{
change.Revert();
}
}
}
/// <summary>
/// Focuses a control.
/// </summary>
/// <param name="control">The control to focus.</param>
/// <param name="method">The method by which focus was changed.</param>
/// <param name="modifiers">Any input modifiers active at the time of focus.</param>
public void Focus(
IInputElement control,
NavigationMethod method = NavigationMethod.Unspecified,
InputModifiers modifiers = InputModifiers.None)
{
if (control != null)
{
var scope = GetFocusScopeAncestors(control)
.FirstOrDefault();
if (scope != null)
{
Scope = scope;
SetFocusedElement(scope, control, method, modifiers);
}
}
else if (Current != null)
{
// If control is null, set focus to the topmost focus scope.
foreach (var scope in GetFocusScopeAncestors(Current).Reverse().ToList())
{
IInputElement element;
if (_focusScopes.TryGetValue(scope, out element))
{
Focus(element, method);
break;
}
}
}
}
public override void ShowDialog(PropertyValue propertyValue, IInputElement commandSource)
{
ModelPropertyEntryToOwnerActivityConverter propertyEntryConverter =
new ModelPropertyEntryToOwnerActivityConverter();
ModelItem activityModelItem =
(ModelItem)propertyEntryConverter.Convert(propertyValue.ParentProperty, typeof(ModelItem), false, null);
ModelItem parentModelItem =
(ModelItem)propertyEntryConverter.Convert(propertyValue.ParentProperty, typeof(ModelItem), true, null);
EditingContext context = ((IModelTreeItem)activityModelItem).ModelTreeManager.Context;
var inputData = parentModelItem.Properties[propertyValue.ParentProperty.PropertyName].Collection;
DynamicArgumentDesignerOptions options = new DynamicArgumentDesignerOptions
{
Title = propertyValue.ParentProperty.DisplayName,
};
using (EditingScope scope = context.Services.GetRequiredService<ModelTreeManager>().CreateEditingScope(StringResourceDictionary.Instance.GetString("InvokeMethodParameterEditing"), true))
{
if (DynamicArgumentDialog.ShowDialog(activityModelItem, inputData, context, activityModelItem.View, options))
{
scope.Complete();
}
}
}
public WpfUIResizeOperationHandleConnector(ICanvasItem canvasItem, IInputElement parent, IEdgeSnappingEngine snappingEngine)
{
CanvasItem = canvasItem;
Parent = parent;
SnappingEngine = snappingEngine;
Handles = new Dictionary<IInputElement, IPoint>();
}
/// <summary>
/// Unregister one key bound to a particular element
/// </summary>
/// <param name="key"></param>
/// <param name="element"></param>
public static void Unregister(string key, IInputElement element)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
key = NormalizeKey(key);
AccessKeyManager akm = AccessKeyManager.Current;
lock (akm._keyToElements)
{
// Get all elements bound to this key and remove this element
ArrayList elements = (ArrayList)akm._keyToElements[key];
if (elements != null)
{
PurgeDead(elements, element);
if (elements.Count == 0)
{
akm._keyToElements.Remove(key);
}
}
}
}
/// <summary>
/// Register the access key binding to the element that is the accesskey.
/// </summary>
/// <param name="key">When the key is pressed the element OnAccessKey method is called</param>
/// <param name="element">The registration element</param>
public static void Register(string key, IInputElement element)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
key = NormalizeKey(key);
AccessKeyManager akm = AccessKeyManager.Current;
lock (akm._keyToElements)
{
ArrayList elements = (ArrayList)akm._keyToElements[key];
if (elements == null)
{
elements = new ArrayList(1);
akm._keyToElements[key] = elements;
}
else
{
// There were some elements there, remove dead ones
PurgeDead(elements, null);
}
elements.Add(new WeakReference(element));
}
}
private Rect GetBounds(StylusPoint stylusPoint,
Point position,
IInputElement relativeTo,
GeneralTransform elementToRoot,
GeneralTransform rootToElement)
{
// Get width and heith in pixel value
double width = GetStylusPointWidthOrHeight(stylusPoint, /*isWidth*/ true);
double height = GetStylusPointWidthOrHeight(stylusPoint, /*isWidth*/ false);
// Get the position with respect to root
Point rootPoint;
if (elementToRoot == null ||
!elementToRoot.TryTransform(position, out rootPoint))
{
rootPoint = position;
}
// Create a Rect with respect to root and transform it to element coordinate space
Rect rectBounds = new Rect(rootPoint.X - width * 0.5, rootPoint.Y - height * 0.5, width, height);
if (rootToElement != null)
{
rectBounds = rootToElement.TransformBounds(rectBounds);
}
return rectBounds;
}
private Rect GetBounds(StylusPoint stylusPoint, Point position, IInputElement relativeTo)
{
GeneralTransform elementToRoot;
GeneralTransform rootToElement;
GetRootTransforms(relativeTo, out elementToRoot, out rootToElement);
return GetBounds(stylusPoint, position, relativeTo, elementToRoot, rootToElement);
}
public void SetFocusedElement(IInputElement element, bool keyboardNavigated)
{
if (element != this.FocusedElement)
{
var interactive = this.FocusedElement as IInteractive;
if (interactive != null)
{
interactive.RaiseEvent(new RoutedEventArgs
{
RoutedEvent = InputElement.LostFocusEvent,
});
}
this.FocusedElement = element;
interactive = element as IInteractive;
if (interactive != null)
{
interactive.RaiseEvent(new GotFocusEventArgs
{
RoutedEvent = InputElement.GotFocusEvent,
KeyboardNavigated = keyboardNavigated,
});
}
}
}
public void SetFocusedElement(IInputElement element, NavigationMethod method)
{
if (element != FocusedElement)
{
var interactive = FocusedElement as IInteractive;
if (interactive != null)
{
interactive.RaiseEvent(new RoutedEventArgs
{
RoutedEvent = InputElement.LostFocusEvent,
});
}
FocusedElement = element;
interactive = element as IInteractive;
if (interactive != null)
{
interactive.RaiseEvent(new GotFocusEventArgs
{
RoutedEvent = InputElement.GotFocusEvent,
NavigationMethod = method,
});
}
}
}
/// <summary>
/// Focuses a control.
/// </summary>
/// <param name="control">The control to focus.</param>
/// <param name="keyboardNavigated">
/// Whether the control was focused by a keypress (e.g. the Tab key).
/// </param>
public void Focus(IInputElement control, bool keyboardNavigated = false)
{
if (control != null)
{
var scope = GetFocusScopeAncestors(control)
.FirstOrDefault();
if (scope != null)
{
this.Scope = scope;
this.SetFocusedElement(scope, control, keyboardNavigated);
System.Diagnostics.Debug.WriteLine("Focused " + control.GetType().Name);
}
}
else if (this.Current != null)
{
// If control is null, set focus to the topmost focus scope.
foreach (var scope in GetFocusScopeAncestors(this.Current).Reverse().ToList())
{
IInputElement element;
if (this.focusScopes.TryGetValue(scope, out element))
{
this.Focus(element, keyboardNavigated);
break;
}
}
}
}
public ToolBarButtonVM(ICommand command, IInputElement commandTarget, string header, string toolTip, ImageReference? imageReference) {
Command = command;
CommandTarget = commandTarget;
Header = string.IsNullOrEmpty(header) ? null : header;
ToolTip = string.IsNullOrEmpty(toolTip) ? null : toolTip;
ImageReference = imageReference ?? default(ImageReference);
}
private void OnPaste(IInputElement container)
{
using (new WaitWrapper())
using (new TimeCounter("Command.Paste: {0}"))
if (this.FitsCanvas(this.clipboard.Buffer))
{
DesignerCanvas.Toolbox.SetDefault();
DesignerCanvas.DeselectAll();
var newElements = this.clipboard.Buffer
.Select(element =>
{
var newElement = element.Clone();
newElement.UID = Guid.NewGuid();
return newElement;
})
.ToList();
this.NormalizeBuffer(container, newElements);
var newItems = newElements.Select(element => DesignerCanvas.CreateElement(element)).ToList();
newItems.ForEach(item => item.IsSelected = true);
ServiceFactoryBase.Events.GetEvent<ElementAddedEvent>().Publish(DesignerCanvas.SelectedElements.ToList());
newItems.ForEach(item => item.IsSelected = true);
MoveToFrontCommand.Execute();
DesignerCanvas.DesignerChanged();
if (this.clipboard.SourceAction == ClipboardSourceAction.Cut)
this.clipboard.Clear();
}
}
public new void Execute(object parameter, IInputElement element)
{
if (_func != null)
_func(parameter, element);
else if (_funcObj != null)
_funcObj(parameter);
}
/// <summary>
/// Gets the next element in tab order.
/// </summary>
/// <param name="element">The element.</param>
/// <returns>The next element in tab order.</returns>
public static IInputElement GetPreviousInTabOrder(IInputElement element)
{
Contract.Requires<ArgumentNullException>(element != null);
var container = element.GetVisualParent<IInputElement>();
if (container != null)
{
var mode = KeyboardNavigation.GetTabNavigation((InputElement)container);
switch (mode)
{
case KeyboardNavigationMode.Continue:
return GetPreviousInContainer(element, container) ??
GetLastInPreviousContainer(element);
case KeyboardNavigationMode.Cycle:
return GetPreviousInContainer(element, container) ??
GetDescendents(container).LastOrDefault();
default:
return GetLastInPreviousContainer(container);
}
}
else
{
return GetDescendents(element).LastOrDefault();
}
}
/// <summary>
/// Unregisters the access keys associated with the input element.
/// </summary>
/// <param name="element">The input element.</param>
public void Unregister(IInputElement element)
{
foreach (var i in _registered.Where(x => x.Item2 == element).ToList())
{
_registered.Remove(i);
}
}
/// <summary>
/// Instantiates a new instance of this class.
/// </summary>
internal ManipulationCompletedEventArgs(
ManipulationDevice manipulationDevice,
int timestamp,
IInputElement manipulationContainer,
Point origin,
ManipulationDelta total,
ManipulationVelocities velocities,
bool isInertial)
: base(manipulationDevice, timestamp)
{
if (total == null)
{
throw new ArgumentNullException("total");
}
if (velocities == null)
{
throw new ArgumentNullException("velocities");
}
RoutedEvent = Manipulation.ManipulationCompletedEvent;
ManipulationContainer = manipulationContainer;
ManipulationOrigin = origin;
TotalManipulation = total;
FinalVelocities = velocities;
IsInertial = isInertial;
}
/// <summary>
/// Gets the next control in the specified navigation direction.
/// </summary>
/// <param name="element">The element.</param>
/// <param name="direction">The navigation direction.</param>
/// <returns>
/// The next element in the specified direction, or null if <paramref name="element"/>
/// was the last in the requested direction.
/// </returns>
public static IInputElement GetNext(
IInputElement element,
FocusNavigationDirection direction)
{
Contract.Requires<ArgumentNullException>(element != null);
Contract.Requires<ArgumentException>(
direction != FocusNavigationDirection.Next &&
direction != FocusNavigationDirection.Previous);
var container = element.GetVisualParent<IInputElement>();
if (container != null)
{
var isForward = IsForward(direction);
var mode = KeyboardNavigation.GetDirectionalNavigation((InputElement)container);
switch (mode)
{
case KeyboardNavigationMode.Continue:
return GetNextInContainer(element, container, direction) ??
GetFirstInNextContainer(element, direction);
case KeyboardNavigationMode.Cycle:
return GetNextInContainer(element, container, direction) ??
GetFocusableDescendent(container, direction);
case KeyboardNavigationMode.Contained:
return GetNextInContainer(element, container, direction);
default:
return null;
}
}
else
{
return GetFocusableDescendents(element).FirstOrDefault();
}
}
/// <summary>
/// Instantiates a new instance of this class.
/// </summary>
internal ManipulationDeltaEventArgs(
ManipulationDevice manipulationDevice,
int timestamp,
IInputElement manipulationContainer,
Point origin,
ManipulationDelta delta,
ManipulationDelta cumulative,
ManipulationVelocities velocities,
bool isInertial)
: base(manipulationDevice, timestamp)
{
if (delta == null)
{
throw new ArgumentNullException("delta");
}
if (cumulative == null)
{
throw new ArgumentNullException("cumulative");
}
if (velocities == null)
{
throw new ArgumentNullException("velocities");
}
RoutedEvent = Manipulation.ManipulationDeltaEvent;
ManipulationContainer = manipulationContainer;
ManipulationOrigin = origin;
DeltaManipulation = delta;
CumulativeManipulation = cumulative;
Velocities = velocities;
IsInertial = isInertial;
}
public ToolBarButtonVM(ICommand command, IInputElement commandTarget, string header, string toolTip, object image)
{
this.command = command;
this.commandTarget = commandTarget;
this.header = string.IsNullOrEmpty(header) ? null : header;
this.toolTip = string.IsNullOrEmpty(toolTip) ? null : toolTip;
this.image = image;
}
public DragListener(IInputElement target)
{
Target = target;
Target.PreviewMouseLeftButtonDown += Target_MouseDown;
Target.PreviewMouseMove += Target_MouseMove;
Target.PreviewMouseLeftButtonUp += Target_MouseUp;
}
public override TouchPointCollection GetIntermediateTouchPoints(IInputElement relativeTo)
{
return(new TouchPointCollection());
}
/// <summary>
/// Executes a given command if its <see cref="ICommand.CanExecute"/> method
/// indicates it can run.
/// </summary>
/// <param name="command">The command to be executed, or a null reference.</param>
/// <param name="commandParameter">An optional parameter that is associated with
/// the command.</param>
/// <param name="target">The target element on which to raise the command.</param>
public static void ExecuteIfEnabled(this ICommand command, object commandParameter, IInputElement target)
{
if (command == null)
{
return;
}
RoutedCommand rc = command as RoutedCommand;
if (rc != null)
{
//routed commands work on a target
if (rc.CanExecute(commandParameter, target))
{
rc.Execute(commandParameter, target);
}
}
else if (command.CanExecute(commandParameter))
{
command.Execute(commandParameter);
}
}
public DrawLineMouseGesture(LineHandlerExtension l, IInputElement relativeTo, ChangeGroup changeGroup)
{
this.l = l;
this.positionRelativeTo = relativeTo;
this.changeGroup = changeGroup;
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
/// <summary>
/// The constrcutor of TextComposition class.
/// </summary>
public TextComposition(InputManager inputManager, IInputElement source, string resultText) : this(inputManager, source, resultText, TextCompositionAutoComplete.On)
{
}
/// <summary>
/// マウスドラッグ中の移動差分量を流す
/// </summary>
/// <param name="control">対象コントロール</param>
/// <param name="originControl">マウス移動量の原点コントロール</param>
/// <returns>移動差分量</returns>
//public static IObservable<Vector> MouseLeftDragVectorAsObservable(this UIElement control, bool handled = false, IInputElement originControl = null)
//{
// if (originControl is null) originControl = control;
// var mouseDown = control.MouseLeftButtonDownAsObservable(handled).ToUnit();
// var mouseUp = control.MouseLeftButtonUpAsObservable(handled).ToUnit();
// return control.MouseMoveAsObservable(handled)
// .Select(e => e.GetPosition(originControl))
// .Pairwise() // クリック前からPairwiseしておく
// .Select(x => x.NewItem - x.OldItem)
// .SkipUntil(mouseDown)
// .TakeUntil(mouseUp)
// .Repeat();
//}
/// <summary>
/// マウスドラッグ中の絶対座標と移動差分量を流す
/// </summary>
/// <param name="control">対象コントロール</param>
/// <param name="originControl">マウス移動量の原点コントロール</param>
/// <returns>絶対座標と移動差分量</returns>
public static IObservable <(Point point, Vector vector)> MouseLeftDragPointVectorAsObservable(this UIElement control, bool handled = false, IInputElement originControl = null)
{
if (originControl is null)
{
originControl = control;
}
var mouseDown = control.MouseLeftButtonDownAsObservable(handled).ToUnit();
var mouseUp = control.MouseLeftButtonUpAsObservable(handled).ToUnit();
return(control.MouseMoveAsObservable(handled)
.Select(e => e.GetPosition(originControl))
.Pairwise() // クリック前からPairwiseしておく
.Select(x => (point: x.NewItem, vector: x.NewItem - x.OldItem))
.SkipUntil(mouseDown)
.TakeUntil(mouseUp)
.Repeat());
}
/// <summary>
/// Starts listening for the Enter key when the button <see cref="IsDefault"/>.
/// </summary>
/// <param name="root">The input root.</param>
private void ListenForDefault(IInputElement root)
{
root.AddHandler(KeyDownEvent, RootKeyDown);
}
public static MessageToken <TipItem> ShowMessage(FrameworkElement balloon,
ObservableCollection <TipItem> data, int?timeout,
NotifyPosition position = NotifyPosition.ActiveScreen, PopupAnimation animation = PopupAnimation.None)
{
var dispatcher = balloon.Dispatcher;
if (!dispatcher.CheckAccess())
{
return(dispatcher.Invoke(DispatcherPriority.Normal,
(Func <MessageToken <TipItem> >)(() =>
ShowMessage(balloon, data, timeout, position, animation))) as
MessageToken <TipItem>);
}
if (balloon == null)
{
throw new ArgumentNullException("balloon");
}
if (timeout.HasValue && timeout < 500)
{
var msg = "Invalid timeout of {0} milliseconds. Timeout must be at least 500 ms";
msg = String.Format(msg, timeout);
throw new ArgumentOutOfRangeException("timeout", msg);
}
if (LogicalTreeHelper.GetParent(balloon) is Popup parent)
{
parent.Child = null;
var msg =
"Cannot display control [{0}] in a new balloon popup - that control already has a parent. You may consider creating new balloons every time you want to show one.";
msg = String.Format(msg, balloon);
throw new InvalidOperationException(msg);
}
var popup = new Popup();
popup.AllowsTransparency = true;
popup.PopupAnimation = animation;
popup.Placement = PlacementMode.AbsolutePoint;
popup.StaysOpen = true;
popup.DataContext = data;
Point point;
switch (position)
{
case NotifyPosition.Caret:
{
var rect = WindowManager.CurrentWindow.CaretPosition;
var X = (rect.Left + rect.Width / 2 - balloon.ActualWidth / 2);
var Y = (rect.Bottom + rect.Height / 2 - balloon.ActualHeight / 2);
if (X == 0 && Y == 0)
{
goto case NotifyPosition.ActiveWindowCenter;
}
point = new Point(X, Y);
break;
}
case NotifyPosition.ActiveWindowCenter:
{
var rect = WindowManager.CurrentWindow.Rect;
var X = (rect.X + rect.Width / 2 - balloon.ActualWidth / 2);
var Y = (rect.Y + rect.Height / 2 - balloon.ActualHeight / 2);
point = new Point(X, Y);
break;
}
case NotifyPosition.ActiveScreen:
{
var screen = Screen.FromHandle(WindowManager.CurrentWindow.Handle);
if (screen.Equals(Screen.PrimaryScreen))
{
var p = TrayInfo.GetTrayLocation();
point = new Point(p.X, p.Y);
break;
}
var bounds = screen.Bounds;
var X = bounds.X + bounds.Width;
var Y = bounds.Y + bounds.Height;
point = new Point(X, Y);
break;
}
case NotifyPosition.Default:
{
var p = TrayInfo.GetTrayLocation();
point = new Point(p.X, p.Y);
break;
}
default:
throw new ArgumentOutOfRangeException(nameof(position) + " not supported", position, null);
}
popup.Child = balloon;
popup.HorizontalOffset = point.X + 1;
popup.VerticalOffset = point.Y - 2;
balloon.Focusable = true;
IInputElement element = null;
popup.Opened += (s, a) =>
{
element = Keyboard.FocusedElement;
var source = (HwndSource)PresentationSource.FromVisual(balloon);
var handle = source.Handle;
PInvokes.SetForegroundWindow(handle);
Keyboard.Focus(balloon);
};
popup.IsOpen = true;
popup.Focus();
var r = new MessageToken <TipItem>(popup);
popup.Closed += (s, a) =>
{
Keyboard.Focus(element);
r.Close();
};
void TimerTick(object sender, EventArgs e)
{
r.Timer.Tick -= TimerTick;
r.Close();
}
if (timeout.HasValue)
{
r.Timer = new DispatcherTimer {
Interval = TimeSpan.FromMilliseconds(timeout.Value)
};
r.Timer.Tick += TimerTick;
r.Timer.Start();
}
return(r);
}
/// <summary>
/// Retrieves the current touch point for ever touch device that is currently active.
/// </summary>
/// <param name="relativeTo">Defines the coordinate space of the touch point.</param>
/// <returns>A collection of touch points.</returns>
public TouchPointCollection GetTouchPoints(IInputElement relativeTo)
{
return(TouchDevice.GetTouchPoints(relativeTo));
}
private bool RaiseContextMenuOpeningEvent(IInputElement source, double x, double y, bool userInitiated)
{
// Fire the event
ContextMenuEventArgs args = new ContextMenuEventArgs(source, true /* opening */, x, y);
DependencyObject sourceDO = source as DependencyObject;
if (userInitiated && sourceDO != null)
{
if (InputElement.IsUIElement(sourceDO))
{
((UIElement)sourceDO).RaiseEvent(args, userInitiated);
}
else if (InputElement.IsContentElement(sourceDO))
{
((ContentElement)sourceDO).RaiseEvent(args, userInitiated);
}
else if (InputElement.IsUIElement3D(sourceDO))
{
((UIElement3D)sourceDO).RaiseEvent(args, userInitiated);
}
else
{
source.RaiseEvent(args);
}
}
else
{
source.RaiseEvent(args);
}
if (!args.Handled)
{
// No one handled the event, auto show any available ContextMenus
// Saved from the bubble up the tree where we looked for a set ContextMenu property
DependencyObject o = args.TargetElement;
if ((o != null) && ContextMenuService.ContextMenuIsEnabled(o))
{
// Retrieve the value
object menu = ContextMenuService.GetContextMenu(o);
ContextMenu cm = menu as ContextMenu;
cm.SetValue(OwnerProperty, o);
cm.Closed += new RoutedEventHandler(OnContextMenuClosed);
if ((x == -1.0) && (y == -1.0))
{
// We infer this to mean that the ContextMenu was opened with the keyboard
cm.Placement = PlacementMode.Center;
}
else
{
// If there is a CursorLeft and CursorTop, it was opened with the mouse.
cm.Placement = PlacementMode.MousePoint;
}
// Clear any open tooltips
RaiseToolTipClosingEvent(true /*reset */);
cm.SetCurrentValueInternal(ContextMenu.IsOpenProperty, BooleanBoxes.TrueBox);
return(true); // A menu was opened
}
return(false); // There was no menu to open
}
// Clear any open tooltips since someone else opened one
RaiseToolTipClosingEvent(true /*reset */);
return(true); // The event was handled by someone else
}
private void OnPostProcessInput(object sender, ProcessInputEventArgs e)
{
if (e.StagingItem.Input.RoutedEvent == InputManager.InputReportEvent)
{
InputReportEventArgs report = (InputReportEventArgs)e.StagingItem.Input;
if (!report.Handled)
{
if (report.Report.Type == InputType.Mouse)
{
RawMouseInputReport mouseReport = (RawMouseInputReport)report.Report;
if ((mouseReport.Actions & RawMouseActions.AbsoluteMove) == RawMouseActions.AbsoluteMove)
{
if ((Mouse.LeftButton == MouseButtonState.Pressed) ||
(Mouse.RightButton == MouseButtonState.Pressed))
{
RaiseToolTipClosingEvent(true /* reset */);
}
else
{
IInputElement directlyOver = Mouse.PrimaryDevice.RawDirectlyOver;
if (directlyOver != null)
{
Point pt = Mouse.PrimaryDevice.GetPosition(directlyOver);
// If possible, check that the mouse position is within the render bounds
// (avoids mouse capture confusion).
if (Mouse.CapturedMode != CaptureMode.None)
{
// Get the root visual
PresentationSource source = PresentationSource.CriticalFromVisual((DependencyObject)directlyOver);
UIElement rootAsUIElement = source != null ? source.RootVisual as UIElement : null;
if (rootAsUIElement != null)
{
// Get mouse position wrt to root
pt = Mouse.PrimaryDevice.GetPosition(rootAsUIElement);
// Hittest to find the element the mouse is over
IInputElement enabledHit;
rootAsUIElement.InputHitTest(pt, out enabledHit, out directlyOver);
// Find the position of the mouse relative the element that the mouse is over
pt = Mouse.PrimaryDevice.GetPosition(directlyOver);
}
else
{
directlyOver = null;
}
}
if (directlyOver != null)
{
// Process the mouse move
OnMouseMove(directlyOver, pt);
}
}
}
}
else if ((mouseReport.Actions & RawMouseActions.Deactivate) == RawMouseActions.Deactivate)
{
if (LastMouseDirectlyOver != null)
{
LastMouseDirectlyOver = null;
if (LastMouseOverWithToolTip != null)
{
RaiseToolTipClosingEvent(true /* reset */);
// When the user moves the cursor outside of the window,
// clear the LastMouseOverWithToolTip property so if the user returns
// the mouse to the same item, the tooltip will reappear. If
// the deactivation is coming from a window grabbing capture
// (such as Drag and Drop) do not clear the property.
if (MS.Win32.SafeNativeMethods.GetCapture() == IntPtr.Zero)
{
LastMouseOverWithToolTip = null;
}
}
}
}
}
}
}
else if (e.StagingItem.Input.RoutedEvent == Keyboard.KeyDownEvent)
{
ProcessKeyDown(sender, (KeyEventArgs)e.StagingItem.Input);
}
else if (e.StagingItem.Input.RoutedEvent == Keyboard.KeyUpEvent)
{
ProcessKeyUp(sender, (KeyEventArgs)e.StagingItem.Input);
}
else if (e.StagingItem.Input.RoutedEvent == Mouse.MouseUpEvent)
{
ProcessMouseUp(sender, (MouseButtonEventArgs)e.StagingItem.Input);
}
else if (e.StagingItem.Input.RoutedEvent == Mouse.MouseDownEvent)
{
RaiseToolTipClosingEvent(true /* reset */);
}
}
/// <inheritdoc/>
protected override void OnLostKeyboardFocus(KeyboardDevice device, IInputElement oldFocus, IInputElement newFocus, RoutedEventData data)
{
Ultraviolet.GetInput().HideSoftwareKeyboard();
if (PART_Editor != null)
{
PART_Editor.HandleLostKeyboardFocus();
}
UpdateIsSelectionActive();
base.OnLostKeyboardFocus(device, oldFocus, newFocus, data);
}
/// <summary>
/// Retrieves the current touch point of the primary touch device, if one exists.
/// </summary>
/// <param name="relativeTo">Defines the coordinate space of the touch point.</param>
/// <returns>The touch point of the primary device or null if no device is a primary device.</returns>
public TouchPoint GetPrimaryTouchPoint(IInputElement relativeTo)
{
return(TouchDevice.GetPrimaryTouchPoint(relativeTo));
}
protected override void OnCapture(IInputElement element, CaptureMode captureMode)
{
Mouse.PrimaryDevice.Capture(element, captureMode);
}
/// <summary> /// Calculates the position of the stylus relative to a particular element. /// </summary> internal abstract Point GetPosition(IInputElement relativeTo);
public void Deactivate(IInputElement e)
{
e.KeyUp -= E_KeyUp;
_obj.DeattachCommand();
}
/// <summary> /// Returns a StylusPointCollection object for processing the data in the packet. /// This method creates a new StylusPointCollection and copies the data. /// </summary> internal abstract StylusPointCollection GetStylusPoints(IInputElement relativeTo, StylusPointDescription subsetToReformatTo);
/// <summary>
/// Stops listening for the Enter key when the button is no longer <see cref="IsDefault"/>.
/// </summary>
/// <param name="root">The input root.</param>
private void StopListeningForDefault(IInputElement root)
{
root.RemoveHandler(KeyDownEvent, RootKeyDown);
}
/// <summary> /// Returns a StylusPointCollection object for processing the data in the packet. /// This method creates a new StylusPointCollection and copies the data. /// </summary> internal abstract StylusPointCollection GetStylusPoints(IInputElement relativeTo);
/// <summary>
/// マウスドラッグ中の絶対座標を流す
/// </summary>
/// <param name="control">対象コントロール</param>
/// <param name="originControl">マウス移動量の原点コントロール</param>
/// <returns>絶対座標</returns>
public static IObservable <Point> MouseLeftDragPointAsObservable(this UIElement control, bool handled = false, IInputElement originControl = null)
{
if (originControl is null)
{
originControl = control;
}
var mouseDown = control.MouseLeftButtonDownAsObservable(handled).ToUnit();
var mouseUp = control.MouseLeftButtonUpAsObservable(handled).ToUnit();
return(control.MouseMoveAsObservable(handled)
.Select(e => e.GetPosition(originControl))
.SkipUntil(mouseDown)
.TakeUntil(mouseUp)
.Repeat());
}
/// <summary> /// Captures the stylus to a particular element. /// </summary> internal abstract bool Capture(IInputElement element);
private void WindowOnDeactivated(object sender, EventArgs eventArgs)
{
_restoreFocusWindowReactivation = _popup != null?FocusManager.GetFocusedElement((Window)sender) : null;
}
/// <summary> /// Captures the stylus to a particular element. /// </summary> internal abstract bool Capture(IInputElement element, CaptureMode captureMode);
public virtual void Close(IInputElement inputElement = null)
{
DialogHost.CloseDialogCommand.Execute(null, inputElement ?? (this as IDialog).InputElement);
}
/////////////////////////////////////////////////////////////////////
/// <summary>
/// Captures the stylus to a particular element.
/// </summary>
/// <param name="element">
/// The element to capture the stylus to.
/// </param>
public static bool Capture(IInputElement element)
{
return(Capture(element, CaptureMode.Element));
}
/// <summary>
/// Whether the command can be executed with the given parameter on the given target.
/// </summary>
/// <param name="parameter">Parameter to be passed to any command handlers.</param>
/// <param name="target">The target element on which to begin looking for command handlers.</param>
/// <returns>true if the command can be executed, false otherwise.</returns>
public bool CanExecute(object parameter, IInputElement target)
{
bool unused;
return(CriticalCanExecute(parameter, target, false, out unused));
}
/// <summary> /// Checks if descendents of the specified element can be focused. /// </summary> /// <param name="e">The element.</param> /// <returns>True if descendents of the element can be focused.</returns> public static bool CanFocusDescendents(this IInputElement e) => e.IsEnabledCore && e.IsVisible;
/// <summary>
/// Initiates the process of opening the tooltip popup.
/// </summary>
/// <param name="fromKeyboard">
/// Whether this particular event is caused by keyboard focus.
/// This is passed down to the tooltip and the popup to determine its placement.
/// </param>
private void RaiseToolTipOpeningEvent(bool fromKeyboard = false)
{
ResetToolTipTimer();
if (_forceCloseTimer != null)
{
OnForceClose(null, EventArgs.Empty);
}
DependencyObject o = LastObjectWithToolTip;
if (o != null)
{
bool show = true;
IInputElement element = o as IInputElement;
if (element != null)
{
ToolTipEventArgs args = new ToolTipEventArgs(true);
element.RaiseEvent(args);
show = !args.Handled;
}
if (show)
{
object tooltip = ToolTipService.GetToolTip(o);
ToolTip tip = tooltip as ToolTip;
if (tip != null)
{
_currentToolTip = tip;
_ownToolTip = false;
}
else if ((_currentToolTip == null) || !_ownToolTip)
{
_currentToolTip = new ToolTip();
_ownToolTip = true;
_currentToolTip.SetValue(ServiceOwnedProperty, BooleanBoxes.TrueBox);
// Bind the content of the tooltip to the ToolTip attached property
Binding binding = new Binding();
binding.Path = new PropertyPath(ToolTipService.ToolTipProperty);
binding.Mode = BindingMode.OneWay;
binding.Source = o;
_currentToolTip.SetBinding(ToolTip.ContentProperty, binding);
}
if (!_currentToolTip.StaysOpen)
{
// The popup takes capture in this case, which causes us to hit test to the wrong window.
// We do not support this scenario. Cleanup and then throw and exception.
throw new NotSupportedException(SR.Get(SRID.ToolTipStaysOpenFalseNotAllowed));
}
_currentToolTip.SetValue(OwnerProperty, o);
_currentToolTip.Opened += OnToolTipOpened;
_currentToolTip.Closed += OnToolTipClosed;
_currentToolTip.FromKeyboard = fromKeyboard;
_currentToolTip.IsOpen = true;
ToolTipTimer = new DispatcherTimer(DispatcherPriority.Normal);
ToolTipTimer.Interval = TimeSpan.FromMilliseconds(ToolTipService.GetShowDuration(o));
ToolTipTimer.Tick += new EventHandler(OnRaiseToolTipClosingEvent);
ToolTipTimer.Start();
}
}
}
/// <summary>
/// Closes the current tooltip, firing a Closing event if necessary.
/// </summary>
/// <param name="reset">
/// When false, will continue to treat input as if the tooltip were open so that
/// the tooltip of the current element won't re-open. Example: Clicking on a button
/// will hide the tooltip, but when the mouse is released, the tooltip should not
/// appear unless the mouse is moved off and then back on the button.
/// </param>
private void RaiseToolTipClosingEvent(bool reset)
{
ResetToolTipTimer();
if (reset)
{
LastChecked = null;
}
DependencyObject o = LastObjectWithToolTip;
if (o != null)
{
if (_currentToolTip != null)
{
bool isOpen = _currentToolTip.IsOpen;
try
{
if (isOpen)
{
IInputElement element = o as IInputElement;
if (element != null)
{
element.RaiseEvent(new ToolTipEventArgs(false));
}
}
}
finally
{
if (isOpen)
{
_currentToolTip.IsOpen = false;
// Setting IsOpen makes call outs to app code. So it is possible that
// the _currentToolTip is ----d as a result of an action there. If that
// were the case we do not need to set off the timer to close the tooltip.
if (_currentToolTip != null)
{
// Keep references and owner set for the fade out or slide animation
// Owner is released when animation completes
_forceCloseTimer = new DispatcherTimer(DispatcherPriority.Normal);
_forceCloseTimer.Interval = Popup.AnimationDelayTime;
_forceCloseTimer.Tick += new EventHandler(OnForceClose);
_forceCloseTimer.Tag = _currentToolTip;
_forceCloseTimer.Start();
}
_quickShow = true;
ToolTipTimer = new DispatcherTimer(DispatcherPriority.Normal);
ToolTipTimer.Interval = TimeSpan.FromMilliseconds(ToolTipService.GetBetweenShowDelay(o));
ToolTipTimer.Tick += new EventHandler(OnBetweenShowDelay);
ToolTipTimer.Start();
}
else
{
// Release owner now
_currentToolTip.ClearValue(OwnerProperty);
if (_ownToolTip)
{
BindingOperations.ClearBinding(_currentToolTip, ToolTip.ContentProperty);
}
}
_currentToolTip.FromKeyboard = false;
_currentToolTip = null;
}
}
}
}
internal bool HandleLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (false != ignoreMouseClick)
{
ignoreMouseClick = false;
return(false);
}
MouseClickHistory curClick = new MouseClickHistory(sender, e);
bool eventHandled = false;
bool returnFocusToSearch = true;
if (this.currentState == State.Connection)
{
// Clicking on the canvas while connecting simply cancels
// the operation and drop the temporary connector.
SetCurrentState(State.None);
eventHandled = true; // Mouse event handled.
}
else if (this.currentState == State.None)
{
// Record the mouse down position.
IInputElement element = sender as IInputElement;
mouseDownPos = e.GetPosition(element);
// We'll see if there is any node being clicked on. If so,
// then the state machine should initiate a drag operation.
if (null != GetSelectableFromPoint(mouseDownPos))
{
InitiateDragSequence();
}
else
{
if ((e.Source is Dynamo.Controls.EndlessGrid) == false)
{
InitiateWindowSelectionSequence();
}
else if (!MouseClickHistory.CheckIsDoubleClick(prevClick, curClick))
{
InitiateWindowSelectionSequence();
}
else
{
// Double-clicking on the background grid results in
// a code block node being created, in which case we
// should keep the input focus on the code block to
// avoid it being dismissed (with empty content).
//
CreateCodeBlockNode(mouseDownPos);
returnFocusToSearch = false;
curClick = null;
}
}
prevClick = curClick;
eventHandled = true; // Mouse event handled.
}
else if (this.currentState == State.PanMode)
{
var c = CursorLibrary.GetCursor(CursorSet.HandPanActive);
owningWorkspace.CurrentCursor = c;
}
else if (this.currentState == State.OrbitMode)
{
var c = CursorLibrary.GetCursor(CursorSet.HandPanActive);
owningWorkspace.CurrentCursor = c;
}
if (returnFocusToSearch != false)
{
owningWorkspace.DynamoViewModel.ReturnFocusToSearch();
}
return(eventHandled);
}
/// <inheritdoc/>
protected override void OnGotKeyboardFocus(KeyboardDevice device, IInputElement oldFocus, IInputElement newFocus, RoutedEventData data)
{
UpdateTextInputRegion();
Ultraviolet.GetInput().ShowSoftwareKeyboard(KeyboardMode.Text);
if (PART_Editor != null)
{
PART_Editor.HandleGotKeyboardFocus();
}
UpdateIsSelectionActive();
base.OnGotKeyboardFocus(device, oldFocus, newFocus, data);
}