Beispiel #1
0
        void MouseUp(object sender, PointerReleasedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonReleased)
            {
                MouseMove(sender, e);

                if (old != null)
                {
                    bool[]     u    = old.ToArray();
                    bool[]     r    = _filter.Filter.ToArray();
                    List <int> path = Track.GetPath(_filter);

                    Program.Project.Undo.Add($"MacroFilter Changed", () => {
                        Track.TraversePath <MacroFilter>(path).Filter = u.ToArray();
                    }, () => {
                        Track.TraversePath <MacroFilter>(path).Filter = r.ToArray();
                    });

                    old = null;
                }

                mouseHeld = false;
                mouseOver = null;

                e.Pointer.Capture(null);
                MacrosGrid.Cursor = new Cursor(StandardCursorType.Arrow);
            }
        }
        private void AddPenPointerEvent(PointerEventType eventType, PointerUpdateKind updateKind, bool isPress, StylusEventArgs e)
        {
            var p = e.GetPosition(element);

            var point = new PointerPoint();

            FillPointInformation(ref point,
                                 eventType,
                                 PointerDeviceType.Pen,
                                 updateKind,
                                 p);

            // if this was a press - try to determine which button was pressed
            if (isPress)
            {
                if (e.Inverted)
                {
                    point.IsRightButtonPressed = true;
                }
                else
                {
                    point.IsLeftButtonPressed = true;
                }
            }

            manager.AddPointerEvent(ref point);
        }
Beispiel #3
0
        async void MouseUp(object sender, PointerReleasedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (mouseHeld)
            {
                if (MouseButton == PointerUpdateKind.LeftButtonReleased)
                {
                    bool remove = false;

                    if (File.Exists(_path))
                    {
                        Opened?.Invoke(_path);
                    }
                    else
                    {
                        remove = await ShouldRemove();
                    }

                    if (remove)
                    {
                        Removed?.Invoke(this, _path);
                    }
                }
                else if (MouseButton == PointerUpdateKind.RightButtonReleased)
                {
                    ((ApolloContextMenu)this.Resources["InfoContextMenu"]).Open((Control)sender);
                }

                mouseHeld = false;
            }
        }
Beispiel #4
0
        public static int Key(PointerUpdateKind puk)
        {
            int key;

            switch (puk)
            {
            case PointerUpdateKind.LeftButtonPressed:
            case PointerUpdateKind.LeftButtonReleased:
                key = 0;
                break;

            case PointerUpdateKind.RightButtonPressed:
            case PointerUpdateKind.RightButtonReleased:
                key = 1;
                break;

            case PointerUpdateKind.MiddleButtonPressed:
            case PointerUpdateKind.MiddleButtonReleased:
                key = 2;
                break;

            case PointerUpdateKind.Other:
                key = 6;
                break;

            default:
                key = -1;
                break;
            }

            return(key);
        }
Beispiel #5
0
        public void DragFailed(PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.RightButtonPressed)
            {
                ApolloContextMenu menu      = DeviceContextMenu;
                List <ISelect>    selection = Track.Get(_device)?.Window?.Selection.Selection;

                if (selection.Count == 1)
                {
                    if (selection[0] is Group group && group.Count == 1)
                    {
                        menu = GroupContextMenu;
                    }

                    else if (selection[0] is Choke)
                    {
                        menu = ChokeContextMenu;
                    }
                }

                DeviceMute.Header = GroupMute.Header = ChokeMute.Header = ((Device)selection.First()).Enabled? "Mute" : "Unmute";

                menu.Open(Draggable);
            }
        private void FillPointInformation(ref PointerPoint point,
                                          PointerEventType eventType,
                                          PointerDeviceType deviceType,
                                          PointerUpdateKind updateKind,
                                          System.Windows.Point positionPoint)
        {
            var position = new Vector2((float)(positionPoint.X / element.ActualWidth), (float)(positionPoint.Y / element.ActualHeight));

            position.Saturate();

            point.EventType              = eventType;
            point.DeviceType             = deviceType;
            point.KeyModifiers           = GetPressedKeyModifiers();
            point.PointerId              = 0;
            point.Position               = position;
            point.Timestamp              = (ulong)DateTime.Now.Ticks;
            point.ContactRect            = new RectangleF(position.X, position.Y, 0f, 0f);
            point.IsBarrelButtonPressed  = false;
            point.IsCanceled             = false;
            point.IsEraser               = false;
            point.IsHorizontalMouseWheel = false;
            point.IsInRange              = false;
            point.IsInverted             = false;
            point.IsPrimary              = true;
            point.MouseWheelDelta        = 0;
            point.Orientation            = 0f;
            point.TouchConfidence        = false;
            point.Twist             = 0f;
            point.XTilt             = 0f;
            point.YTilt             = 0f;
            point.PointerUpdateKind = updateKind;
        }
Beispiel #7
0
        void MouseUp(object sender, PointerReleasedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonReleased)
            {
                MouseMove(sender, e);

                if (old != null)
                {
                    Program.Project.Undo.Add(new MacroFilter.FilterUndoEntry(
                                                 _filter,
                                                 old.ToArray()
                                                 ));

                    old = null;
                }

                mouseHeld = false;
                mouseOver = null;

                e.Pointer.Capture(null);
                MacrosGrid.Cursor = new Cursor(StandardCursorType.Arrow);
            }
        }
Beispiel #8
0
        public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind)
        {
            PointerUpdateKind     = kind;
            IsLeftButtonPressed   = modifiers.HasFlag(RawInputModifiers.LeftMouseButton);
            IsMiddleButtonPressed = modifiers.HasFlag(RawInputModifiers.MiddleMouseButton);
            IsRightButtonPressed  = modifiers.HasFlag(RawInputModifiers.RightMouseButton);

            // The underlying input source might be reporting the previous state,
            // so make sure that we reflect the current state

            if (kind == PointerUpdateKind.LeftButtonPressed)
            {
                IsLeftButtonPressed = true;
            }
            if (kind == PointerUpdateKind.LeftButtonReleased)
            {
                IsLeftButtonPressed = false;
            }
            if (kind == PointerUpdateKind.MiddleButtonPressed)
            {
                IsMiddleButtonPressed = true;
            }
            if (kind == PointerUpdateKind.MiddleButtonReleased)
            {
                IsMiddleButtonPressed = false;
            }
            if (kind == PointerUpdateKind.RightButtonPressed)
            {
                IsRightButtonPressed = true;
            }
            if (kind == PointerUpdateKind.RightButtonReleased)
            {
                IsRightButtonPressed = false;
            }
        }
Beispiel #9
0
 public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind,
                               float twist, float pressure, float xTilt, float yTilt
                               ) : this(modifiers, kind)
 {
     Twist    = twist;
     Pressure = pressure;
     XTilt    = xTilt;
     YTilt    = yTilt;
 }
Beispiel #10
0
        void Click(object sender, PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonPressed)
            {
                Selected?.Invoke(Program.Project.Undo.History.IndexOf(_entry));
            }
        }
Beispiel #11
0
        void MouseDown(object sender, PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonPressed || MouseButton == PointerUpdateKind.RightButtonPressed)
            {
                mouseHeld = true;
            }
        }
Beispiel #12
0
        public void Select(PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonPressed || (MouseButton == PointerUpdateKind.RightButtonPressed && !Selected))
            {
                Track.Get(_chain)?.Window?.Selection.Select(_chain, e.KeyModifiers.HasFlag(KeyModifiers.Shift));
            }
        }
Beispiel #13
0
        void Select(PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonPressed || (MouseButton == PointerUpdateKind.RightButtonPressed && !selected))
            {
                _pattern.Window?.Selection.Select(Viewer.Frame, e.KeyModifiers.HasFlag(KeyModifiers.Shift));
            }
        }
Beispiel #14
0
        public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind)
        {
            PointerUpdateKind = kind;

            IsLeftButtonPressed   = modifiers.HasAllFlags(RawInputModifiers.LeftMouseButton);
            IsMiddleButtonPressed = modifiers.HasAllFlags(RawInputModifiers.MiddleMouseButton);
            IsRightButtonPressed  = modifiers.HasAllFlags(RawInputModifiers.RightMouseButton);
            IsXButton1Pressed     = modifiers.HasAllFlags(RawInputModifiers.XButton1MouseButton);
            IsXButton2Pressed     = modifiers.HasAllFlags(RawInputModifiers.XButton2MouseButton);
            IsInverted            = modifiers.HasAllFlags(RawInputModifiers.PenInverted);
            IsEraser = modifiers.HasAllFlags(RawInputModifiers.PenEraser);
            IsBarrelButtonPressed = modifiers.HasAllFlags(RawInputModifiers.PenBarrelButton);

            // The underlying input source might be reporting the previous state,
            // so make sure that we reflect the current state

            if (kind == PointerUpdateKind.LeftButtonPressed)
            {
                IsLeftButtonPressed = true;
            }
            if (kind == PointerUpdateKind.LeftButtonReleased)
            {
                IsLeftButtonPressed = false;
            }
            if (kind == PointerUpdateKind.MiddleButtonPressed)
            {
                IsMiddleButtonPressed = true;
            }
            if (kind == PointerUpdateKind.MiddleButtonReleased)
            {
                IsMiddleButtonPressed = false;
            }
            if (kind == PointerUpdateKind.RightButtonPressed)
            {
                IsRightButtonPressed = true;
            }
            if (kind == PointerUpdateKind.RightButtonReleased)
            {
                IsRightButtonPressed = false;
            }
            if (kind == PointerUpdateKind.XButton1Pressed)
            {
                IsXButton1Pressed = true;
            }
            if (kind == PointerUpdateKind.XButton1Released)
            {
                IsXButton1Pressed = false;
            }
            if (kind == PointerUpdateKind.XButton2Pressed)
            {
                IsXButton2Pressed = true;
            }
            if (kind == PointerUpdateKind.XButton2Released)
            {
                IsXButton2Pressed = false;
            }
        }
Beispiel #15
0
        void Click(object sender, PointerReleasedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.RightButtonReleased)
            {
                ((ApolloContextMenu)this.Resources["TrackContextMenu"]).Open((Control)sender);
            }

            e.Handled = true;
        }
Beispiel #16
0
        void ResizeUp(object sender, PointerReleasedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonReleased)
            {
                ResizeMove(sender, e);

                mouseHeld = false;
                e.Pointer.Capture(null);
            }
        }
Beispiel #17
0
        public async void Drag(object sender, PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (!selected)
            {
                Select(e);
            }

            DataObject dragData = new DataObject();

            dragData.Set("device", Track.Get(_device)?.Window?.Selection.Selection);

            App.Dragging = true;
            DragDropEffects result = await DragDrop.DoDragDrop(e, dragData, DragDropEffects.Move);

            App.Dragging = false;

            if (result == DragDropEffects.None)
            {
                if (selected)
                {
                    Select(e);
                }

                if (MouseButton == PointerUpdateKind.RightButtonPressed)
                {
                    ApolloContextMenu menu      = DeviceContextMenu;
                    List <ISelect>    selection = Track.Get(_device)?.Window?.Selection.Selection;

                    if (selection.Count == 1)
                    {
                        if (selection[0] is Group group && group.Count == 1)
                        {
                            menu = GroupContextMenu;
                        }

                        else if (selection[0] is Choke)
                        {
                            menu = ChokeContextMenu;
                        }
                    }

                    DeviceMute.Header = GroupMute.Header = ChokeMute.Header = ((Device)selection.First()).Enabled? "Mute" : "Unmute";

                    menu.Open(Draggable);
                }
                else if (MouseButton == PointerUpdateKind.LeftButtonPressed && e.ClickCount == 2)
                {
                    _device.Collapsed = !_device.Collapsed;
                    DeviceCollapsed?.Invoke(_device.ParentIndex.Value);
                }
            }
Beispiel #18
0
        public void Drag(object sender, PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if ((e.KeyModifiers & ~KeyModifiers.Shift) == KeyModifiers.Alt)
            {
                _pattern.Window?.PlayFrom(this, (e.KeyModifiers & ~KeyModifiers.Alt) == KeyModifiers.Shift);
                return;
            }

            DragDrop.Drag(_pattern.Window?.Selection, e);
        }
Beispiel #19
0
        protected override void Click(PointerReleasedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonReleased)
            {
                InvokeAdded();
            }
            else if (MouseButton == PointerUpdateKind.RightButtonReleased)
            {
                ((ApolloContextMenu)this.Resources["ActionContextMenu"]).Open(Icon);
            }
        }
Beispiel #20
0
        void ResizeDown(object sender, PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonPressed)
            {
                mouseHeld = true;
                e.Pointer.Capture(ResizeArea);

                original = e.GetPosition(ResizeArea).X;

                ResizeMove(sender, e);
            }
        }
        void MouseDown(object sender, PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonPressed)
            {
                mouseHeld = true;

                e.Pointer.Capture(Root);
                Root.Cursor = new Cursor(StandardCursorType.Hand);

                PadStarted?.Invoke(Array.IndexOf(Buttons, (IControl)sender));
                MouseMove(sender, e);
            }
        }
Beispiel #22
0
        void Canvas_MouseDown(object sender, PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            contextOpenPosition = e.GetPosition(canvas).X - 7;

            if (MouseButton == PointerUpdateKind.LeftButtonPressed && e.ClickCount == 2)
            {
                NewColor();
            }
            else if (MouseButton == PointerUpdateKind.RightButtonPressed)
            {
                ((ApolloContextMenu)this.Resources["GradientContextMenu"]).Open(this);
            }
        }
Beispiel #23
0
        public void DragFailed(PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonPressed && e.ClickCount == 2)
            {
                TrackWindow.Create(_track, (Window)this.GetVisualRoot());
            }

            if (MouseButton == PointerUpdateKind.RightButtonPressed)
            {
                MuteItem.Header = ((Track)Program.Project.Window?.Selection.Selection.First()).Enabled? "Mute" : "Unmute";
                ((ApolloContextMenu)this.Resources["TrackContextMenu"]).Open(Draggable);
            }
        }
Beispiel #24
0
        public void DragFailed(PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.LeftButtonPressed)
            {
                ChainExpanded?.Invoke(_chain.ParentIndex.Value);
            }

            if (MouseButton == PointerUpdateKind.RightButtonPressed)
            {
                MuteItem.Header = ((Chain)Track.Get(_chain)?.Window?.Selection.Selection.First()).Enabled? "Mute" : "Unmute";
                ((ApolloContextMenu)this.Resources["ChainContextMenu"]).Open(Draggable);
            }
        }
Beispiel #25
0
 public static TP.PointerUpdateKind Convert(PointerUpdateKind value)
 {
     return(value switch
     {
         PointerUpdateKind.LeftButtonPressed => TP.PointerUpdateKind.LeftButtonPressed,
         PointerUpdateKind.LeftButtonReleased => TP.PointerUpdateKind.LeftButtonReleased,
         PointerUpdateKind.MiddleButtonPressed => TP.PointerUpdateKind.MiddleButtonPressed,
         PointerUpdateKind.MiddleButtonReleased => TP.PointerUpdateKind.MiddleButtonReleased,
         PointerUpdateKind.RightButtonPressed => TP.PointerUpdateKind.RightButtonPressed,
         PointerUpdateKind.RightButtonReleased => TP.PointerUpdateKind.RightButtonReleased,
         PointerUpdateKind.XButton1Pressed => TP.PointerUpdateKind.XButton1Pressed,
         PointerUpdateKind.XButton1Released => TP.PointerUpdateKind.XButton1Released,
         PointerUpdateKind.XButton2Pressed => TP.PointerUpdateKind.XButton2Pressed,
         PointerUpdateKind.XButton2Released => TP.PointerUpdateKind.XButton2Released,
         _ => TP.PointerUpdateKind.Other
     });
Beispiel #26
0
 public static MouseButton GetMouseButton(this PointerUpdateKind kind)
 {
     if (kind == PointerUpdateKind.LeftButtonPressed || kind == PointerUpdateKind.LeftButtonReleased)
     {
         return(MouseButton.Left);
     }
     if (kind == PointerUpdateKind.MiddleButtonPressed || kind == PointerUpdateKind.MiddleButtonReleased)
     {
         return(MouseButton.Middle);
     }
     if (kind == PointerUpdateKind.RightButtonPressed || kind == PointerUpdateKind.RightButtonReleased)
     {
         return(MouseButton.Right);
     }
     return(MouseButton.None);
 }
Beispiel #27
0
        public async void Drag(object sender, PointerPressedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if ((e.KeyModifiers & ~KeyModifiers.Shift) == KeyModifiers.Alt)
            {
                _pattern.Window?.PlayFrom(this, (e.KeyModifiers & ~KeyModifiers.Alt) == KeyModifiers.Shift);
                return;
            }

            if (!selected)
            {
                Select(e);
            }

            DataObject dragData = new DataObject();

            dragData.Set("frame", _pattern.Window?.Selection.Selection);

            App.Dragging = true;
            DragDropEffects result = await DragDrop.DoDragDrop(e, dragData, DragDropEffects.Move);

            App.Dragging = false;

            if (result == DragDropEffects.None)
            {
                if (selected)
                {
                    Select(e);
                }

                if (MouseButton == PointerUpdateKind.LeftButtonPressed)
                {
                    FrameSelected?.Invoke(Viewer.Frame.ParentIndex.Value);
                }

                if (MouseButton == PointerUpdateKind.RightButtonPressed)
                {
                    ((ApolloContextMenu)this.Resources["FrameContextMenu"]).Open(Viewer);
                }

                if (MouseButton == PointerUpdateKind.MiddleButtonPressed)
                {
                    _pattern.Window?.PlayFrom(this, e.KeyModifiers == KeyModifiers.Shift);
                }
            }
        }
Beispiel #28
0
 static bool HasChanged(bool was, bool @is, PointerUpdateKind pressed, PointerUpdateKind released, ref PointerUpdateKind update)
 {
     if (was == @is)
     {
         return(false);
     }
     else if (was)
     {
         update = released;
         return(true);
     }
     else
     {
         update = pressed;
         return(true);
     }
 }
Beispiel #29
0
        void Click(object sender, PointerReleasedEventArgs e)
        {
            PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;

            if (MouseButton == PointerUpdateKind.RightButtonReleased)
            {
                if (sender == DropZoneBefore)
                {
                    ((ApolloContextMenu)this.Resources["DeviceContextMenuBefore"]).Open((Control)sender);
                }
                else if (sender == DropZoneAfter)
                {
                    ((ApolloContextMenu)this.Resources["DeviceContextMenuAfter"]).Open((Control)sender);
                }
            }

            e.Handled = true;
        }
        private void AddMousePointerEvent(PointerEventType eventType, PointerUpdateKind updateKind, int wheelDelta, MouseEventArgs e)
        {
            var p = Mouse.GetPosition(element);

            var point = new PointerPoint();

            FillPointInformation(ref point,
                                 eventType,
                                 PointerDeviceType.Mouse,
                                 updateKind,
                                 p);

            FillPressedButtons(e, ref point);

            point.MouseWheelDelta = wheelDelta;

            manager.AddPointerEvent(ref point);
        }
        private void FillPointInformation(ref PointerPoint point,
                                          PointerEventType eventType,
                                          PointerDeviceType deviceType,
                                          PointerUpdateKind updateKind,
                                          System.Windows.Point positionPoint)
        {
            var position = new Vector2((float)(positionPoint.X / element.ActualWidth), (float)(positionPoint.Y / element.ActualHeight));
            position.Saturate();

            point.EventType = eventType;
            point.DeviceType = deviceType;
            point.KeyModifiers = GetPressedKeyModifiers();
            point.PointerId = 0;
            point.Position = position;
            point.Timestamp = (ulong)DateTime.Now.Ticks;
            point.ContactRect = new RectangleF(position.X, position.Y, 0f, 0f);
            point.IsBarrelButtonPressed = false;
            point.IsCanceled = false;
            point.IsEraser = false;
            point.IsHorizontalMouseWheel = false;
            point.IsInRange = false;
            point.IsInverted = false;
            point.IsPrimary = true;
            point.MouseWheelDelta = 0;
            point.Orientation = 0f;
            point.TouchConfidence = false;
            point.Twist = 0f;
            point.XTilt = 0f;
            point.YTilt = 0f;
            point.PointerUpdateKind = updateKind;
        }
        private void AddMousePointerEvent(PointerEventType eventType, PointerUpdateKind updateKind, int wheelDelta, MouseEventArgs e)
        {
            var p = Mouse.GetPosition(element);

            var point = new PointerPoint();

            FillPointInformation(ref point,
                                 eventType,
                                 PointerDeviceType.Mouse,
                                 updateKind,
                                 p);

            FillPressedButtons(e, ref point);

            point.MouseWheelDelta = wheelDelta;

            manager.AddPointerEvent(ref point);
        }
        private void AddPenPointerEvent(PointerEventType eventType, PointerUpdateKind updateKind, bool isPress, StylusEventArgs e)
        {
            var p = e.GetPosition(element);

            var point = new PointerPoint();

            FillPointInformation(ref point,
                                 eventType,
                                 PointerDeviceType.Pen,
                                 updateKind,
                                 p);

            // if this was a press - try to determine which button was pressed
            if (isPress)
            {
                if (e.Inverted)
                    point.IsRightButtonPressed = true;
                else
                    point.IsLeftButtonPressed = true;
            }

            manager.AddPointerEvent(ref point);
        }
        /// <summary>
        /// Creates a <see cref="PointerPoint"/> instance from current mouse state.
        /// </summary>
        /// <param name="eventType">The type of pointer event.</param>
        /// <param name="pointerUpdateKind">The kind of pointer event.</param>
        /// <param name="wheelDelta">The current mouse wheel delta.</param>
        private void CreateAndAddPoint(PointerEventType eventType, PointerUpdateKind pointerUpdateKind, int wheelDelta)
        {
            var p = control.PointToClient(Control.MousePosition);

            var mouseButtons = Control.MouseButtons;

            var clientSize = control.ClientSize;
            var position = new Vector2((float)p.X / clientSize.Width, (float)p.Y / clientSize.Height);
            position.Saturate();

            var point = new PointerPoint
                   {
                       EventType = eventType,
                       DeviceType = PointerDeviceType.Mouse,
                       KeyModifiers = GetCurrentKeyModifiers(),
                       PointerId = 0,
                       Position = position,
                       Timestamp = (ulong)DateTime.Now.Ticks,
                       ContactRect = new RectangleF(position.X, position.Y, 0f, 0f),
                       IsBarrelButtonPressed = false,
                       IsCanceled = false,
                       IsEraser = false,
                       IsHorizontalMouseWheel = false,
                       IsInRange = false,
                       IsInverted = false,
                       IsLeftButtonPressed = (mouseButtons & MouseButtons.Left) != 0,
                       IsMiddleButtonPressed = (mouseButtons & MouseButtons.Middle) != 0,
                       IsPrimary = true,
                       IsRightButtonPressed = (mouseButtons & MouseButtons.Right) != 0,
                       IsXButton1Pressed = (mouseButtons & MouseButtons.XButton1) != 0,
                       IsXButton2Pressed = (mouseButtons & MouseButtons.XButton2) != 0,
                       MouseWheelDelta = wheelDelta,
                       Orientation = 0f,
                       TouchConfidence = false, // ?
                       Twist = 0f,
                       XTilt = 0f,
                       YTilt = 0f,
                       PointerUpdateKind = pointerUpdateKind
                   };

            manager.AddPointerEvent(ref point);
        }