示例#1
0
        private void MouseMoved(object sender, MouseMoveEventArgs args)
        {
            GetBorders(out int x1, out int y1, out int x2, out int y2);

            bool mouseMove =
                (_mouseX != (_mouseX = (int)((Mouse.X - x1) / ScaleX))) |
                (_mouseY != (_mouseY = (int)((Mouse.Y - y1) / ScaleY)));

            if (!mouseMove)
            {
                return;
            }

            MouseState mouse   = Mouse.GetState();
            CButton    buttons = CButton.None;

            if (mouse.IsButtonDown(MouseButton.Left))
            {
                buttons |= CButton.Left;
            }
            if (mouse.IsButtonDown(MouseButton.Right))
            {
                buttons |= CButton.Right;
            }

            _runtime.InvokeMouseMove(new ScreenEventArgs(_mouseX, _mouseY, buttons));
        }
示例#2
0
        protected override void OnUpdateFrame(FrameEventArgs e)
        {
            KeyboardState input = Keyboard.GetState();

            game.UpdateFPS(this.RenderFrequency);
            //Console.WriteLine(graphics.fps);
            MouseState mouseState = Mouse.GetCursorState();

            CheckKey(input);
            Point cPoint = this.PointToClient(new Point(mouseState.X, mouseState.Y));

            if (this.Focused)
            {
                game.UpdateMousePoint(cPoint.X, cPoint.Y,
                                      mouseState.IsButtonDown(MouseButton.Left),
                                      mouseState.IsButtonDown(MouseButton.Middle),
                                      mouseState.IsButtonDown(MouseButton.Right));
            }
            game.Update();
            game.CleanUp();
            if (input.IsKeyDown(Key.Escape) || game.DoQuit() || game.DoReload())
            {
                Exit();
            }
            base.OnUpdateFrame(e);
        }
示例#3
0
 public static bool LeftMouseButtonDown()
 {
     if (!foc)
     {
         return(false);
     }
     lock (msLocker) { return(msState.IsButtonDown(MouseButton.Left)); }
 }
示例#4
0
        public bool WasButtonPressed(MouseButtons button)
        {
            if (!_game.IsActive)
            {
                return(false);
            }

            return(_lastMouseState.IsButtonUp(button) && _currentMouseState.IsButtonDown(button));
        }
示例#5
0
 public static bool GetMouseButtonDown(MouseButton button)
 {
     if (mouseState.IsButtonDown(button) && !mouseInput[(int)button].pressed)
     {
         mouseInput[(int)button].pressed = true;
         pressedButtons.Add((int)button);
     }
     return(mouseInput[(int)button].pressed && !mouseInput[(int)button].held);
 }
示例#6
0
        /// <override></override>
        public override bool ProcessMouseEvent(IDiagramPresenter diagramPresenter, MouseEventArgsDg e)
        {
            if (diagramPresenter == null)
            {
                throw new ArgumentNullException("diagramPresenter");
            }
            bool result = false;

            MouseState newMouseState = MouseState.Empty;

            newMouseState.Buttons   = e.Buttons;
            newMouseState.Modifiers = e.Modifiers;
            diagramPresenter.ControlToDiagram(e.Position, out newMouseState.Position);

            diagramPresenter.SuspendUpdate();
            try {
                switch (e.EventType)
                {
                case MouseEventType.MouseDown:
                    timer.Stop();
                    break;

                case MouseEventType.MouseMove:
                    if (CurrentMouseState.Position != newMouseState.Position)
                    {
                        if (newMouseState.IsButtonDown(MouseButtonsDg.Left) &&
                            diagramPresenter.Project.SecurityManager.IsGranted(Permission.Insert))
                        {
                            diagramPresenter.ControlToDiagram(e.Position, out p);
                            currentStroke.Add(p.X, p.Y);
                        }
                        diagramPresenter.SetCursor(penCursorId);
                    }
                    Invalidate(diagramPresenter);
                    break;

                case MouseEventType.MouseUp:
                    if (newMouseState.IsButtonDown(MouseButtonsDg.Left) &&
                        diagramPresenter.Project.SecurityManager.IsGranted(Permission.Insert))
                    {
                        StartToolAction(diagramPresenter, 0, newMouseState, false);

                        strokeSet.Add(currentStroke);
                        currentStroke = new Stroke();
                        timer.Start();
                    }
                    break;

                default: throw new NShapeUnsupportedValueException(e.EventType);
                }
            } finally { diagramPresenter.ResumeUpdate(); }
            base.ProcessMouseEvent(diagramPresenter, e);
            return(result);
        }
示例#7
0
 public static bool GetMouseDown(MouseButton button)
 {
     if (!Engine.MainWindow.IsFocused)
     {
         return(false);
     }
     if (!mouseState.WasButtonDown(button) && mouseState.IsButtonDown(button))
     {
         return(true);
     }
     return(false);
 }
示例#8
0
        public bool SatisfiesCondition(KeyboardState prevkb, MouseState prevMb, KeyboardState kb, MouseState mb)
        {
            var pressed = kb.GetPressedKeys();

            var isctrl  = ((int)modifiers & (int)Modifiers.Ctrl) == (int)Modifiers.Ctrl;
            var isshift = ((int)modifiers & (int)Modifiers.Shift) == (int)Modifiers.Shift;
            var isalt   = ((int)modifiers & (int)Modifiers.Alt) == (int)Modifiers.Alt;

            if (isctrl)
            {
                if (!pressed.Contains(Keys.LeftControl) && !pressed.Contains(Keys.RightControl))
                {
                    return(false);
                }
            }

            if (isshift)
            {
                if (!pressed.Contains(Keys.LeftShift) && !pressed.Contains(Keys.RightShift))
                {
                    return(false);
                }
            }

            if (isalt)
            {
                if (!pressed.Contains(Keys.LeftAlt) && !pressed.Contains(Keys.RightAlt))
                {
                    return(false);
                }
            }

            switch (type)
            {
            case InputBindingType.Pressed:
                return(mb.IsButtonDown(button) && !prevMb.IsButtonDown(button));

            case InputBindingType.Released:
                return(!mb.IsButtonDown(button) && prevMb.IsButtonDown(button));

            case InputBindingType.Held:
                return(mb.IsButtonDown(button) && prevMb.IsButtonDown(button));

            case InputBindingType.StateChanged:
                return(mb.X != prevMb.X || mb.Y != prevMb.Y);

            case InputBindingType.None:
                return(true);

            default:
                return(false);
            }
        }
示例#9
0
 public InputState State(Layer.Input.MouseButton button)
 {
     if (_nativeMouse.IsButtonDown((OpenTK.Windowing.GraphicsLibraryFramework.MouseButton)button))
     {
         if (_nativeMouse.WasButtonDown((OpenTK.Windowing.GraphicsLibraryFramework.MouseButton)button))
         {
             return(InputState.Repeat);
         }
         return(InputState.Press);
     }
     return(InputState.Release);
 }
示例#10
0
 public bool this[MouseButton mb]
 {
     get
     {
         return(state.IsButtonDown(mb));
     }
 }
示例#11
0
        private void checkmouse()
        {
            MouseState mstate = Mouse.GetState();

            Vector2 CurrentMousePosition = new Vector2(mstate.X, mstate.Y);

            if (mstate.IsButtonDown(MouseButton.Left) && mic)
            {
                Vector2 delta = CurrentMousePosition - PreviousMousePosition;
                cam.AddRotation(-delta.X, -delta.Y);

                Rectangle glControlScreenRect = lakiToolGLControl1.RectangleToScreen(lakiToolGLControl1.ClientRectangle);
                if (Cursor.Position.X < glControlScreenRect.Left)
                {
                    Cursor.Position = new Point(glControlScreenRect.Right, Cursor.Position.Y);
                }
                else if (Cursor.Position.X > glControlScreenRect.Right)
                {
                    Cursor.Position = new Point(glControlScreenRect.Left, Cursor.Position.Y);
                }
                if (Cursor.Position.Y < glControlScreenRect.Top)
                {
                    Cursor.Position = new Point(Cursor.Position.X, glControlScreenRect.Bottom);
                }
                else if (Cursor.Position.Y > glControlScreenRect.Bottom)
                {
                    Cursor.Position = new Point(Cursor.Position.X, glControlScreenRect.Top);
                }
            }

            PreviousMousePosition = CurrentMousePosition;
        }
示例#12
0
        internal override void Update(Vector2 a_resolution)
        {
            if (m_focused)
            {
                MouseState mouseState = Mouse.GetState();

                if (mouseState.IsButtonDown(MouseButton.Left))
                {
                    Vector2 cursorPos = Input.GetCursorPosition();

                    Vector2 pos  = (TruePosition + a_resolution) / 2;
                    Vector2 size = TrueSize;

                    Vector2 halfSize = size / 2;

                    if (cursorPos.X < pos.X - halfSize.X || cursorPos.Y < pos.Y - halfSize.Y && cursorPos.X > pos.X + halfSize.X || cursorPos.Y > pos.Y + halfSize.Y)
                    {
                        m_focused = false;
                    }
                }

                if (Input.IsKeyPressed(Key.BackSpace) && Text.Length != 0)
                {
                    Text = Text.Substring(0, Text.Length - 1);
                }
            }
        }
示例#13
0
        public void SetMouse(MouseState mouse)
        {
            MouseDown = mouse.IsButtonDown(MouseButton.Left);
            var currPos = new Vector2(mouse.X, mouse.Y);

            MouseDiff = MousePos - currPos;
            MousePos  = currPos;
        }
示例#14
0
        public static MouseButton[] GetDownButtons()
        {
            if (!AcceptKeyboard)
            {
                return(new MouseButton[0]);
            }
            List <MouseButton> list = new List <MouseButton>();

            for (var i = 0; i < (int)MouseButton.LastButton; i++)
            {
                if (mouse.IsButtonDown((MouseButton)i))
                {
                    list.Add((MouseButton)i);
                }
            }
            return(list.ToArray());
        }
示例#15
0
        private void HandleMouse(GameTime gameTime)
        {
            MouseState state = Mouse.GetCursorState();

            if (state.IsButtonDown(MouseButton.Left))
            {
                if (!_hasFirstClicked)
                {
                    _hasFirstClicked = true;
                    _mouseStartState = state;
                }

                if (state != _mouseStartState)
                {
                    float diffX = state.Y - _mouseStartState.Y;
                    float diffY = state.X - _mouseStartState.X;

                    if (Math.Abs(diffX) > MAX_REST_DIFF)
                    {
                        _velocity.X = diffX * 0.5f;
                    }

                    if (Math.Abs(diffY) > MAX_REST_DIFF)
                    {
                        _velocity.Y = diffY * 0.5f;
                    }
                }
            }

            if (state.Wheel != _lastWheelValue)
            {
                var change = _wheelChange + state.Wheel - _lastWheelValue;
                _lastWheelValue = state.Wheel;

                if (Math.Abs(change) >= _maxWheelValue)
                {
                    return;
                }

                _wheelChange = change;

                float addWheelValue = 1.0f;

                if (_wheelChange > 0)
                {
                    addWheelValue -= Math.Min(1.0f, _wheelChange / _maxWheelValue);
                }
                else if (_wheelChange < 0)
                {
                    addWheelValue -= Math.Max(-1.0f, _wheelChange / _maxWheelValue);
                }

                _wheelPower = addWheelValue;
            }
        }
示例#16
0
        public bool MouseCheck(MouseButtons buttons)
        {
            switch (buttons)
            {
            case MouseButtons.WheelDown:
                return(_mouseCurrent.ScrollWheelValue > _mousePrevious.ScrollWheelValue);

            case MouseButtons.WheelUp:
                return(_mouseCurrent.ScrollWheelValue < _mousePrevious.ScrollWheelValue);

            case MouseButtons.WheelLeft:
                return(_mouseCurrent.HorizontalScrollWheelValue < _mousePrevious.HorizontalScrollWheelValue);

            case MouseButtons.WheelRight:
                return(_mouseCurrent.HorizontalScrollWheelValue > _mousePrevious.HorizontalScrollWheelValue);

            default:
                return(_mouseCurrent.IsButtonDown(buttons));
            }
        }
示例#17
0
 protected override void OnMouseMove(MouseMoveEventArgs e)
 {
     base.OnMouseMove(e);
     if (MouseState.IsButtonDown(MouseButton.Button2))
     {
         CameraPitch          -= e.DeltaY * 0.005f;
         CameraPitch           = Math.Clamp(CameraPitch, -MathHelper.PiOver2, MathHelper.PiOver2);
         CameraYaw            += e.DeltaX * 0.005f;
         ActiveCamera.Rotation = Quaternion.FromAxisAngle(Vector3.UnitY, CameraYaw) * Quaternion.FromAxisAngle(Vector3.UnitX, CameraPitch);
     }
 }
 public bool isClickedRising(MouseButton b)
 {
     if (Game.window.Focused)
     {
         return(currentMouseState.IsButtonDown(b) && lastMouseState.IsButtonUp(b));
     }
     else
     {
         return(false);
     }
 }
示例#19
0
        public static void Update()
        {
            #region Keyboard Input
            keyboardState = Keyboard.GetState();
            bool keysReleased = false;
            for (int i = 0; i < pressedKeys.Count; i++)
            {
                if (keyboardState.IsKeyDown((Key)pressedKeys[i]))
                {
                    keyboardInput[pressedKeys[i]].held = true;
                }
                else
                {
                    keyboardInput[pressedKeys[i]].pressed = false;
                    keyboardInput[pressedKeys[i]].held    = false;
                    pressedKeys[i] = -1;
                    keysReleased   = true;
                }
            }
            if (keysReleased)
            {
                pressedKeys.RemoveAll(x => x == -1);
                keysReleased = false;
            }
            #endregion
            #region Mouse Input
            mouseState = Mouse.GetState();
            bool buttonsReleased = false;
            for (int i = 0; i < pressedButtons.Count; i++)
            {
                if (mouseState.IsButtonDown((MouseButton)pressedButtons[i]))
                {
                    mouseInput[pressedButtons[i]].held = true;
                }
                else
                {
                    mouseInput[pressedButtons[i]].pressed = false;
                    mouseInput[pressedButtons[i]].held    = false;
                    pressedButtons[i] = -1;
                    buttonsReleased   = true;
                }
            }
            if (buttonsReleased)
            {
                pressedButtons.RemoveAll(x => x == -1);
                buttonsReleased = false;
            }

            var mousePos = new Vector2(mouseState.X, mouseState.Y);
            MouseDelta   = mousePos - lastMousePos;
            lastMousePos = mousePos;
            #endregion
        }
示例#20
0
        /// <summary>
        /// Update the AngleAroundPlayer of the Camera from the previous frame.
        /// </summary>
        private void UpdateAngleAroundPlayer()
        {
            MouseState mouse = Mouse.GetState();
            float      mouseXCurrentPosition = mouse.X;

            if (mouse.IsButtonDown(MouseButton.Right))
            {
                float mouseXDeltaPosition = mouseXCurrentPosition - MouseXPreviousPosition;

                float angleChange = mouseXDeltaPosition * 0.001f;
                AngleAroundPlayer -= angleChange;
            }
            MouseXPreviousPosition = mouseXCurrentPosition;
        }
示例#21
0
        public void MouseUpdate()
        {
            KeyboardState keybState  = Keyboard.GetState();
            MouseState    mouseState = Mouse.GetState();

            Vector2 mousePos = new Vector2(mouseState.X, mouseState.Y);
            Vector2 delta    = (refMousePos - mousePos);

            if (keybState.IsKeyDown(Key.LShift) && mouseState.IsButtonDown(MouseButton.Middle))
            {
                orientation.AddDelta(delta.X, delta.Y);
            }
            else if (keybState.IsKeyDown(Key.LShift) && mouseState.IsButtonDown(MouseButton.Left) && mouseState.IsButtonDown(MouseButton.Right))
            {
                position.Current   = new Vector3(0f);
                position.Reference = new Vector3(0f);
            }
            else if (mouseState.IsButtonDown(MouseButton.Left))
            {
                delta *= zoom;
                position.AddDelta(delta.X, delta.Y);
            }
        }
示例#22
0
        /// <summary>
        /// Update the Pitch of the Camera from the previous frame.
        /// </summary>
        private void UpdatePitch()
        {
            MouseState mouse = Mouse.GetState();
            float      mouseYCurrentPosition = mouse.Y;

            if (mouse.IsButtonDown(MouseButton.Right))
            {
                float mouseYDeltaPosition = mouseYCurrentPosition - MouseYPreviousPosition;

                float pitchChange = mouseYDeltaPosition * 0.001f;
                Pitch += pitchChange;
            }
            MouseYPreviousPosition = mouseYCurrentPosition;
        }
示例#23
0
        public bool MouseCheckReleased(MouseButtons buttons)
        {
            switch (buttons)
            {
            case MouseButtons.WheelDown:
            case MouseButtons.WheelUp:
            case MouseButtons.WheelLeft:
            case MouseButtons.WheelRight:
                return(false);

            default:
                return(_mouseCurrent.IsButtonUp(buttons) && _mousePrevious.IsButtonDown(buttons));
            }
        }
示例#24
0
        private void UpdateImGuiInput()
        {
            ImGuiIOPtr io = ImGui.GetIO();

            MouseState    MouseState    = Window.MouseState;
            KeyboardState KeyboardState = Window.KeyboardState;

            io.MouseDown[0] = MouseState.IsButtonDown(MouseButton.Left);
            io.MouseDown[1] = MouseState.IsButtonDown(MouseButton.Right);
            io.MouseDown[2] = MouseState.IsButtonDown(MouseButton.Middle);

            var point = new Vector2i((int)MouseState.X, (int)MouseState.Y);  // TODO: check

            io.MousePos    = new System.Numerics.Vector2(point.X, point.Y);
            io.MouseWheel  = MouseScroll.Y;
            io.MouseWheelH = MouseScroll.X;
            MouseScroll    = Vector2.Zero;

            foreach (Key key in Enum.GetValues(typeof(Key)))
            {
                if (key != Key.Unknown)
                {
                    io.KeysDown[(int)key] = KeyboardState.IsKeyDown(key);
                }
            }

            foreach (var c in PressedChars)
            {
                io.AddInputCharacter(c);
            }
            PressedChars.Clear();

            io.KeyCtrl  = KeyboardState.IsKeyDown(Key.ControlLeft) || KeyboardState.IsKeyDown(Key.ControlRight);
            io.KeyAlt   = KeyboardState.IsKeyDown(Key.AltLeft) || KeyboardState.IsKeyDown(Key.AltRight);
            io.KeyShift = KeyboardState.IsKeyDown(Key.ShiftLeft) || KeyboardState.IsKeyDown(Key.ShiftRight);
            io.KeySuper = KeyboardState.IsKeyDown(Key.WinLeft) || KeyboardState.IsKeyDown(Key.WinRight);
        }
示例#25
0
        private void UpdateImGuiInput()
        {
            ImGuiIOPtr io = ImGui.GetIO();

            MouseState    MouseState    = Engine.MainWindow.MouseState;
            KeyboardState KeyboardState = Engine.MainWindow.KeyboardState;

            io.MouseDown[0] = MouseState.IsButtonDown(MouseButton.Left);
            io.MouseDown[1] = MouseState.IsButtonDown(MouseButton.Right);
            io.MouseDown[2] = MouseState.IsButtonDown(MouseButton.Middle);

            var point = MouseState.Position;

            io.MousePos = new Vector2(point.X, point.Y);

            io.MouseWheel  = MouseState.ScrollDelta.Y;
            io.MouseWheelH = MouseState.ScrollDelta.X;

            foreach (Keys key in Enum.GetValues(typeof(Keys)))
            {
                if (key != Keys.Unknown)
                {
                    io.KeysDown[(int)key] = KeyboardState.IsKeyDown(key);
                }
            }

            foreach (var c in PressedChars)
            {
                io.AddInputCharacter(c);
            }
            PressedChars.Clear();

            io.KeyCtrl  = KeyboardState.IsKeyDown(Keys.LeftControl) || KeyboardState.IsKeyDown(Keys.RightControl);
            io.KeyAlt   = KeyboardState.IsKeyDown(Keys.LeftAlt) || KeyboardState.IsKeyDown(Keys.RightAlt);
            io.KeyShift = KeyboardState.IsKeyDown(Keys.LeftShift) || KeyboardState.IsKeyDown(Keys.RightShift);
            io.KeySuper = KeyboardState.IsKeyDown(Keys.LeftSuper) || KeyboardState.IsKeyDown(Keys.RightSuper);
        }
示例#26
0
        void HandleKeyboard()
        {
            var keyState = Keyboard.GetState();

            if (keyState.IsKeyDown(Key.Escape))
            {
                m_mainWindow.Exit();
            }

            MouseState mouseState = Mouse.GetState();

            if (mouseState.IsButtonDown(MouseButton.Left))
            {
                //Console.WriteLine("mouse left btn down");
            }
        }
 public override void ManageInput(KeyboardState keyboardState, MouseState mouseState, float mouseWheelDelta, Point mousePosition)
 {
     if (keyboardState.IsKeyDown(Key.Space))
     {
         begin = true;
     }
     if (keyboardState.IsKeyDown(Key.BackSpace))
     {
         Reset();
     }
     if (mouseState.IsButtonDown(MouseButton.Left) && mousePosition != null)
     {
         Vector3 mousePositionCartesianCoordinates = GetMousePositionCartesianCoordinates(GetMousePositionUnitCoordinates(mousePosition));
         CreateNode(loader, mousePositionCartesianCoordinates, new Vector3(0, 1, 0));
     }
 }
示例#28
0
        private static void DrawNode(SpriteBatch spriteBatch, Node node, int startX, ref int startY)
        {
            if (startY > JackApp.WindowHeight)
            {
                // note: maybe add some scroll instead of stopping drawing
                return;
            }
            Rectangle textBounds = _font.GetBounds(node.Name);
            Rectangle rectangle  = new Rectangle(
                // note: multiply with scale
                startX - 10, startY - 20, textBounds.Width, textBounds.Height
                );
            bool hovered = rectangle.Includes(Input.MousePosition);

            if (hovered && _focusedNode != node)
            {
                MouseState ms = Mouse.GetState();
                if (ms.IsButtonDown(MouseButton.Left))
                {
                    _focusedNode = node;
                }
            }

            spriteBatch.DrawString(node.Name, new Vector2(startX, startY), new Vector2(2.0f), hovered ? _accentColor : Color.White, _font);

            if (node.Children != null)
            {
                for (int i = 0; i < node.Children.Count; i++)
                {
                    spriteBatch.DrawLine(
                        new Vector2(startX, startY + _yStep),
                        new Vector2(startX, startY + _yStep / 2),
                        2, Color.DeepPink
                        );

                    int sx = startX + _xStep;
                    startY += _yStep;

                    spriteBatch.DrawLine(
                        new Vector2(startX, startY),
                        new Vector2(startX + _xStep - 15, startY),
                        2, Color.DeepPink
                        );
                    DrawNode(spriteBatch, node.Children[i], sx, ref startY);
                }
            }
        }
示例#29
0
 public bool test(KeyboardState ks, MouseState ms)
 {
     if (!isMouse)
     {
         if (ks.IsKeyDown(key) && testModifiers(ks))
         {
             return(true);
         }
     }
     else
     {
         if (ms.IsButtonDown(button) && testModifiers(ks))
         {
             return(true);
         }
     }
     return(false);
 }
示例#30
0
        /// <summary>
        /// Tick operation for control inputs.
        /// </summary>
        public static void ControlTick()
        {
            MouseState ms = Mouse.GetState();

            if (ms.IsButtonDown(MouseButton.Left))
            {
                GameInternal.Angle -= (ms.X - MouseCoords.X) * 0.005f;
                //GameInternal.Angle = (GameInternal.Angle < 0f) ? 360f : (GameInternal.Angle > 360f) ? 0f : GameInternal.Angle;
                GameInternal.Pitch -= (ms.Y - MouseCoords.Y) * 0.005f;
                GameInternal.Pitch  = (GameInternal.Pitch < -GameInternal.Degrees89) ? -GameInternal.Degrees89 : (GameInternal.Pitch > GameInternal.Degrees89) ? GameInternal.Degrees89 : GameInternal.Pitch;
            }
            MouseCoords = new Vector2(ms.X, ms.Y);
            Quaternion Q = GameInternal.GetRotation();

            if (InputHelpers.CurrentVector != Vector3.Zero)
            {
                GameInternal.Center += Vector3.Transform(InputHelpers.CurrentVector, Q);
            }
        }
示例#31
0
		private bool ProcessMouseClick(IDiagramPresenter diagramPresenter, MouseState mouseState) {
			Debug.Print("ProcessMouseClick");
			bool result = false;
			switch (CurrentAction) {
				case Action.None:
					if (mouseState.IsButtonDown(MouseButtonsDg.Left)) {
						if (diagramPresenter.SelectedShapes.Count > 0)
							diagramPresenter.UnselectAll();

						ShapeAtCursorInfo targetShapeInfo = FindShapeAtCursor(diagramPresenter, mouseState.X, mouseState.Y, ControlPointCapabilities.Glue, diagramPresenter.ZoomedGripSize, false);
						if (IsExtendLineFeasible(CurrentAction, targetShapeInfo.Shape, targetShapeInfo.ControlPointId)) {
							if (diagramPresenter.Project.SecurityManager.IsGranted(Permission.Layout, targetShapeInfo.Shape)) {
								ExtendLine(diagramPresenter, mouseState, targetShapeInfo);
								result = true;
							}
						} else {
							// If no other ToolAction is in Progress (e.g. drawing a line or moving a point),
							// a normal MouseClick starts a new line in Point-By-Point mode
							if (diagramPresenter.Project.SecurityManager.IsGranted(Permission.Insert, Template.Shape)) {
								CreateLine(diagramPresenter, mouseState);
								result = true;
							}
						}
					} else if (mouseState.IsButtonDown(MouseButtonsDg.Right)) {
						Cancel();
						result = true;
					}
					break;

				case Action.CreateLine:
				case Action.ExtendLine:
					if (mouseState.IsButtonDown(MouseButtonsDg.Left)) {
						Invalidate(ActionDiagramPresenter);
						bool doFinishLine = false;
						// If the line has reached the MaxVertexCount limit, create it
						if (PreviewLinearShape.VertexCount >= PreviewLinearShape.MaxVertexCount)
							doFinishLine = true;
						else {
							// Check if it has to be connected to a shape or connection point
							ShapeAtCursorInfo shapeAtCursorInfo = base.FindShapeAtCursor(ActionDiagramPresenter, mouseState.X, mouseState.Y, ControlPointCapabilities.Connect, diagramPresenter.ZoomedGripSize, false);
							if (!shapeAtCursorInfo.IsEmpty && !shapeAtCursorInfo.IsCursorAtGluePoint)
								doFinishLine = true;
							else AddNewPoint(ActionDiagramPresenter, mouseState);
						}
						// Create line if necessary
						if (doFinishLine) {
							if (CurrentAction == Action.CreateLine)
								FinishLine(ActionDiagramPresenter, mouseState, false);
							else FinishExtendLine(ActionDiagramPresenter, mouseState, false);

							while (IsToolActionPending)
								EndToolAction();
							OnToolExecuted(ExecutedEventArgs);
						}
					} else if (mouseState.IsButtonDown(MouseButtonsDg.Right)) {
#if DEBUG_DIAGNOSTICS
						Assert(PreviewShape != null);
#endif
						// When creating a line, the new line has to have more than the minimum number of 
						// vertices because the last vertex (sticking to the mouse cursor) will not be created.
						if (CurrentAction == Action.CreateLine) {
							if (PreviewLinearShape.VertexCount <= PreviewLinearShape.MinVertexCount)
								Cancel();
							else FinishLine(ActionDiagramPresenter, mouseState, true);
						} else {
							// When extending a line, the new line has to have more than the minimum number of 
							// vertices and more than the original line because the last vertex will not be created.
							if (PreviewLinearShape.VertexCount <= PreviewLinearShape.MinVertexCount
								|| PreviewLinearShape.VertexCount - 1 == modifiedLinearShape.VertexCount)
								Cancel();
							else FinishExtendLine(ActionDiagramPresenter, mouseState, true);
						}

						while (IsToolActionPending)
							EndToolAction();
						OnToolExecuted(ExecutedEventArgs);
					}
					result = true;
					break;

				default: throw new NShapeUnsupportedValueException(CurrentAction);
			}
			Invalidate(diagramPresenter);
			return result;
		}
示例#32
0
		/// <summary>
		/// Decide which tool action is suitable for the current mouse state.
		/// </summary>
		private Action DetermineMouseMoveAction(IDiagramPresenter diagramPresenter, MouseState mouseState, ShapeAtCursorInfo shapeAtCursorInfo) {
			switch (CurrentAction) {
				case Action.None:
				case Action.MoveHandle:
				case Action.MoveShape:
				case Action.SelectWithFrame:
					// Do not change the current action
					return CurrentAction;

				case Action.Select:
				case Action.EditCaption:
					if (mouseState.IsButtonDown(MouseButtonsDg.Left)) {
						// Check if cursor is over a control point and moving grips or rotating is feasible
						if (SelectedShapeAtCursorInfo.IsCursorAtGrip) {
							if (IsMoveHandleFeasible(diagramPresenter, SelectedShapeAtCursorInfo))
								return Action.MoveHandle;
							else if (IsRotatatingFeasible(diagramPresenter, SelectedShapeAtCursorInfo))
								return Action.PrepareRotate;
							else return Action.SelectWithFrame;
						} else {
							// If there is no shape under the cursor, start a SelectWithFrame action,
							// otherwise start a MoveShape action
							bool canMove = false;
							if (!SelectedShapeAtCursorInfo.IsEmpty) {
								// If there are selected shapes, check these shapes...
								canMove = IsMoveShapeFeasible(diagramPresenter, mouseState, SelectedShapeAtCursorInfo);
							} else {
								// ... otherwise check the shape under the cursor as it will be selected 
								// before starting a move action
								canMove = IsMoveShapeFeasible(diagramPresenter, mouseState, shapeAtCursorInfo);
							}
							if (canMove)
								return Action.MoveShape;
							else return Action.SelectWithFrame;
						}
					}
					return CurrentAction;

				case Action.PrepareRotate:
					if (mouseState.IsButtonDown(MouseButtonsDg.Left)) {
						// If the mouse has left the min rotate range, start 'real' rotating
						if (IsMinRotateRangeExceeded(diagramPresenter, mouseState))
							return Action.Rotate;
						else return CurrentAction;
					} else return CurrentAction;

				case Action.Rotate:
					if (mouseState.IsButtonDown(MouseButtonsDg.Left)) {
						// If the mouse has entered the min rotate range, start showing rotating hint
						if (!IsMinRotateRangeExceeded(diagramPresenter, mouseState))
							return Action.PrepareRotate;
						else return CurrentAction;
					} else return CurrentAction;

				default: throw new NShapeUnsupportedValueException(CurrentAction);
			}
		}
示例#33
0
		/// <summary>
		/// Decide which tool action is suitable for the current mouse state.
		/// </summary>
		private Action DetermineMouseDownAction(IDiagramPresenter diagramPresenter, MouseState mouseState) {
			if (mouseState.IsButtonDown(MouseButtonsDg.Left)) {
				if (!SelectedShapeAtCursorInfo.IsEmpty
					&& IsEditCaptionFeasible(diagramPresenter, mouseState, SelectedShapeAtCursorInfo)) {
					// If the cursor is not over a caption of a selected shape when clicking left mouse button, 
					// we assume the user wants to select something
					// Same thing if no other action is granted.
					return Action.EditCaption;
				} else {
					// Moving shapes and handles is initiated as soon as the user starts drag action (move mouse 
					// while mouse button is pressed) 
					// If the user does not start a drag action, this will result in (un)selecting shapes.
					return Action.Select;
				}
			} else if (mouseState.IsButtonDown(MouseButtonsDg.Right)) {
				// Abort current action when clicking right mouse button
				return Action.None;
			} else {
				// Ignore other pressed mouse buttons
				return CurrentAction;
			}
		}
示例#34
0
		private bool ProcessMouseMove(IDiagramPresenter diagramPresenter, MouseState mouseState) {
			bool result = true;

			if (!SelectedShapeAtCursorInfo.IsEmpty &&
				!diagramPresenter.SelectedShapes.Contains(SelectedShapeAtCursorInfo.Shape))
				SelectedShapeAtCursorInfo.Clear();

			Action newAction;
			switch (CurrentAction) {
				case Action.None:
					result = false;
					SetSelectedShapeAtCursor(diagramPresenter, mouseState.X, mouseState.Y, diagramPresenter.ZoomedGripSize, ControlPointCapabilities.All);
					Invalidate(diagramPresenter);
					break;

				case Action.Select:
				case Action.EditCaption:
					// Find unselected shape under the mouse cursor
					ShapeAtCursorInfo shapeAtCursorInfo = ShapeAtCursorInfo.Empty;
					newAction = CurrentAction;
					if (mouseState.IsButtonDown(MouseButtonsDg.Left)) {
						if (IsDragActionFeasible(mouseState, MouseButtonsDg.Left)) {
							// Determine new drag action
							shapeAtCursorInfo = FindShapeAtCursor(ActionDiagramPresenter, ActionStartMouseState.X, ActionStartMouseState.Y, ControlPointCapabilities.None, 0, true);
							newAction = DetermineMouseMoveAction(ActionDiagramPresenter, ActionStartMouseState, shapeAtCursorInfo);
						}
					} else newAction = DetermineMouseMoveAction(ActionDiagramPresenter, ActionStartMouseState, shapeAtCursorInfo);

					// If the action has changed, prepare and start the new action
					if (newAction != CurrentAction) {
						switch (newAction) {
							// Select --> SelectWithFrame
							case Action.SelectWithFrame:
#if DEBUG_DIAGNOSTICS
								Assert(CurrentAction == Action.Select);
#endif
								StartToolAction(diagramPresenter, (int)newAction, ActionStartMouseState, true);
								PrepareSelectionFrame(ActionDiagramPresenter, ActionStartMouseState);
								break;

							// Select --> (Select shape and) move shape
							case Action.MoveShape:
							case Action.MoveHandle:
							case Action.PrepareRotate:
#if DEBUG_DIAGNOSTICS
								Assert(CurrentAction == Action.Select || CurrentAction == Action.EditCaption);
#endif
								if (SelectedShapeAtCursorInfo.IsEmpty) {
									// Select shape at cursor before start dragging it
									PerformSelection(ActionDiagramPresenter, ActionStartMouseState, shapeAtCursorInfo);
									SetSelectedShapeAtCursor(diagramPresenter, ActionStartMouseState.X, ActionStartMouseState.Y, 0, ControlPointCapabilities.None);
#if DEBUG_DIAGNOSTICS
									Assert(!SelectedShapeAtCursorInfo.IsEmpty);
#endif
								}
								// Init moving shape
#if DEBUG_DIAGNOSTICS
								Assert(!SelectedShapeAtCursorInfo.IsEmpty);
#endif
								CreatePreviewShapes(ActionDiagramPresenter);
								StartToolAction(diagramPresenter, (int)newAction, ActionStartMouseState, true);
								PrepareMoveShapePreview(ActionDiagramPresenter, ActionStartMouseState);
								break;

							// Select --> (Select shape and) rotate shape / edit shape caption
							case Action.Rotate:
							case Action.EditCaption:
							case Action.None:
							case Action.Select:
								Debug.Fail("Unhandled change of CurrentAction.");
								break;
							default:
								Debug.Fail(string.Format("Unexpected {0} value: {1}", CurrentAction.GetType().Name, CurrentAction));
								break;
						}
						//currentToolAction = newAction;
					}
					Invalidate(ActionDiagramPresenter);
					break;

				case Action.SelectWithFrame:
					PrepareSelectionFrame(ActionDiagramPresenter, mouseState);
					break;

				case Action.MoveHandle:
#if DEBUG_DIAGNOSTICS
					Assert(IsMoveHandleFeasible(ActionDiagramPresenter, SelectedShapeAtCursorInfo));
#endif
					PrepareMoveHandlePreview(ActionDiagramPresenter, mouseState);
					break;

				case Action.MoveShape:
					PrepareMoveShapePreview(diagramPresenter, mouseState);
					break;

				case Action.PrepareRotate:
				case Action.Rotate:
#if DEBUG_DIAGNOSTICS
					Assert(IsRotatatingFeasible(ActionDiagramPresenter, SelectedShapeAtCursorInfo));
#endif
					newAction = CurrentAction;
					// Find unselected shape under the mouse cursor
					newAction = DetermineMouseMoveAction(ActionDiagramPresenter, mouseState, SelectedShapeAtCursorInfo);

					// If the action has changed, prepare and start the new action
					if (newAction != CurrentAction) {
						switch (newAction) {
							// Rotate shape -> Prepare shape rotation
							case Action.PrepareRotate:
#if DEBUG_DIAGNOSTICS
								Assert(CurrentAction == Action.Rotate);
#endif
								EndToolAction();
								ClearPreviews();
								break;

							// Prepare shape rotation -> Rotate shape
							case Action.Rotate:
#if DEBUG_DIAGNOSTICS
								Assert(CurrentAction == Action.PrepareRotate);
#endif
								StartToolAction(ActionDiagramPresenter, (int)newAction, mouseState, false);
								CreatePreviewShapes(ActionDiagramPresenter);
								break;

							case Action.SelectWithFrame:
							case Action.MoveShape:
							case Action.EditCaption:
							case Action.MoveHandle:
							case Action.None:
							case Action.Select:
								Debug.Fail("Unhandled change of CurrentAction.");
								break;
							default:
								Debug.Fail(string.Format("Unexpected {0} value: {1}", CurrentAction.GetType().Name, CurrentAction));
								break;
						}
						//currentToolAction = newAction;
					}

					PrepareRotatePreview(ActionDiagramPresenter, mouseState);
					break;

				default: throw new NShapeUnsupportedValueException(typeof(Action), CurrentAction);
			}

			int cursorId = DetermineCursor(diagramPresenter, mouseState);
			if (CurrentAction == Action.None) diagramPresenter.SetCursor(cursorId);
			else ActionDiagramPresenter.SetCursor(cursorId);

			return result;
		}
		private bool ProcessMouseUp(IDiagramPresenter diagramPresenter, MouseState mouseState)
		{
			bool result = false;

			if (!selectedShapeAtCursorInfo.IsEmpty &&
			    !diagramPresenter.SelectedShapes.Contains(selectedShapeAtCursorInfo.Shape))
				selectedShapeAtCursorInfo.Clear();

			switch (CurrentAction) {
				case Action.None:
					// do nothing
					break;

				case Action.Select:
					// Perform selection, but only if it was with the left mouse button. If it was right mouse, ignore it. (Select is only
					// initiated on right mouse earlier (in ProcessMouseDown) to allow it to 'refine' into other drag actions. If it's
					// still a select by MouseUp, then we can ignore it.)
					if (!mouseState.IsButtonDown(MouseButtonsDg.Right)) {
						ShapeAtCursorInfo shapeAtCursorInfo = FindShapeAtCursor(diagramPresenter, mouseState.X, mouseState.Y,
						                                                        ControlPointCapabilities.None, 0, false);
						result = PerformSelection(ActionDiagramPresenter, mouseState, shapeAtCursorInfo);
						SetSelectedShapeAtCursor(ActionDiagramPresenter, mouseState.X, mouseState.Y, ActionDiagramPresenter.ZoomedGripSize,
						                         ControlPointCapabilities.All);
					}
					EndToolAction();
					break;

				case Action.SelectWithFrame:
					// select all selectedShapes within the frame
					result = PerformFrameSelection(ActionDiagramPresenter, mouseState);
					while (IsToolActionPending)
						EndToolAction();
					break;

				case Action.MoveHandle:
					result = PerformMoveHandle(ActionDiagramPresenter);
					while (IsToolActionPending)
						EndToolAction();
					break;

				case Action.MoveShape:
					result = PerformMoveShape(ActionDiagramPresenter);
					while (IsToolActionPending)
						EndToolAction();
					break;

				case Action.ConnectShapes:
					result = FinishConnection(ActionDiagramPresenter);
					while (IsToolActionPending)
						EndToolAction();
					break;

				default:
					throw new NShapeUnsupportedValueException(CurrentAction);
			}

			SetSelectedShapeAtCursor(diagramPresenter, mouseState.X, mouseState.Y, diagramPresenter.ZoomedGripSize,
			                         ControlPointCapabilities.All);
			diagramPresenter.SetCursor(DetermineCursor(diagramPresenter, mouseState));

			OnToolExecuted(ExecutedEventArgs);
			return result;
		}
示例#36
0
        public void Update()
        {
            state = OpenTK.Input.Mouse.GetState();

            if(HWUpdate)
            {
                var p = gameWindow.PointToClient(new System.Drawing.Point(state.X, state.Y));

                if(!lastHWUpdate)
                {
                    var lastx = x;
                    var lasty = y;

                    offsetx = x - p.X;
                    offsety = y - p.Y;
                }

                x = p.X + offsetx;
                y = p.Y + offsety;
            }
            else
            {
                x = gameWindow.Mouse.X;
                y = gameWindow.Mouse.Y;
            }

            lastHWUpdate = HWUpdate;

            var wheelValue = state.WheelPrecise;
            wheel = state.WheelPrecise;

            for(int i = 0; i < allButtons.Length; i++)
            {
                MouseButton button = allButtons[i];

                if (state.IsButtonDown(button))
                {
                    MouseDown(button);
                }
                else if(downButtons[button])
                {
                    MouseUp(button);
                }
            }
        }
示例#37
0
		private bool IsDragActionFeasible(MouseState mouseState, MouseButtonsDg button) {
			int dx = 0, dy = 0;
			if (mouseState.IsButtonDown(button) && IsToolActionPending) {
				// Check the minimum drag distance before switching to a drag action
				dx = Math.Abs(mouseState.X - ActionStartMouseState.X);
				dy = Math.Abs(mouseState.Y - ActionStartMouseState.Y);
			}
			return (dx >= MinimumDragDistance.Width || dy >= MinimumDragDistance.Height);
		}
		/// <summary>
		/// Decide which tool action is suitable for the current mouse state.
		/// </summary>
		private Action DetermineMouseMoveAction(IDiagramPresenter diagramPresenter, MouseState mouseState,
		                                        ShapeAtCursorInfo shapeAtCursorInfo)
		{
			switch (CurrentAction) {
				case Action.None:
				case Action.MoveHandle:
				case Action.MoveShape:
				case Action.SelectWithFrame:
				case Action.ConnectShapes:
					// Do not change the current action
					return CurrentAction;

				case Action.Select:
					if (mouseState.IsButtonDown(MouseButtonsDg.Left)) {
						// if we're doing something with the left mouse button, it will be a 'drag' style action
						if (!IsDragActionFeasible(mouseState)) {
							return CurrentAction;
						}

						// Check if cursor is over a control point and moving grips is feasible
						if (selectedShapeAtCursorInfo.IsCursorAtGrip) {
							if (IsMoveHandleFeasible(diagramPresenter, mouseState, selectedShapeAtCursorInfo))
								return Action.MoveHandle;
							else
								return Action.SelectWithFrame;
						}
						else {
							// If there is no shape under the cursor, start a SelectWithFrame action,
							// otherwise start a MoveShape action
							bool canMove = false;
							if (!selectedShapeAtCursorInfo.IsEmpty) {
								// If there are selected shapes, check these shapes...
								canMove = IsMoveShapeFeasible(diagramPresenter, mouseState, selectedShapeAtCursorInfo);
							}
							else {
								// ... otherwise check the shape under the cursor as it will be selected 
								// before starting a move action
								canMove = IsMoveShapeFeasible(diagramPresenter, mouseState, shapeAtCursorInfo);
							}
							return canMove ? Action.MoveShape : Action.SelectWithFrame;
						}
					}
					else if (mouseState.IsButtonDown(MouseButtonsDg.Right)) {
						if (IsConnectFromShapeFeasible(diagramPresenter, mouseState, shapeAtCursorInfo)) {
							return Action.ConnectShapes;
						}
					}
					return CurrentAction;

				default:
					throw new NShapeUnsupportedValueException(CurrentAction);
			}
		}
		/// <summary>
		/// Decide which tool action is suitable for the current mouse state.
		/// </summary>
		private Action DetermineMouseDownAction(IDiagramPresenter diagramPresenter, MouseState mouseState)
		{
			if (mouseState.IsButtonDown(MouseButtonsDg.Left) || mouseState.IsButtonDown(MouseButtonsDg.Right)) {
				// if left or right buttons are down, start a 'select' action. This will refine to an
				// appropriate drag action later on (when mouse moving) based on the mouse button, otherwise
				// it will (de)select the shape on mouseup
				return Action.Select;
			}
			// Ignore other pressed mouse buttons
			return CurrentAction;
		}