public static void ProcessMouse(int oriX,int oriY){
			
			EventArgs evnt=null;
			var pressed = false;
			prevMouseState =curMouseState;
			curMouseState = Mouse.GetCursorState ();
            Gwen.Input.InputHandler.HoveredControl =input.m_Canvas.GetControlAt(curMouseState.X - oriX, curMouseState.Y - oriY);
            foreach (var mouseCode in mouseCodes)
				if (curMouseState[mouseCode]!=prevMouseState[mouseCode]){
                    evnt = new MouseButtonEventArgs(curMouseState.X - oriX, curMouseState.Y - oriY, mouseCode, true);//last param bugged
                    //evnt = new MouseButtonEventArgs (curMouseState.X, curMouseState.Y, mouseCode,true);//last param bugged
					if (curMouseState [mouseCode]) {
						pressed = true;
                        Gwen.Input.InputHandler.MouseFocus = Gwen.Input.InputHandler.HoveredControl;
                        OnMouseDown?.Invoke ((MouseButtonEventArgs)evnt);
					} else {
						OnMouseUp?.Invoke ((MouseButtonEventArgs)evnt);

					}
				}
			Vector2 delta =MainWindow.lastPos - new Vector2(curMouseState.X, curMouseState.Y);
			if (Math.Abs (delta.X) > 0 || Math.Abs (delta.Y) > 0) {
				
				evnt = new MouseMoveEventArgs (curMouseState.X-oriX, curMouseState.Y-oriY,(int)delta.X,(int)delta.Y);
				OnMouseMove?.Invoke (evnt as MouseMoveEventArgs);
			}
			input.ProcessMouseMessage (evnt,pressed);
			MainWindow.lastPos = new Vector2 (curMouseState.X, curMouseState.Y);
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="EVEMon.TrayIcon"/> class with the specfied container.
 /// </summary>
 /// <param name="container">An <see cref="System.ComponentModel.IContainer"/> that represents the container for the <see cref="EVEMon.TrayIcon"/> control.</param>
 public TrayIcon(IContainer container)
 {
     if (container != null)
         container.Add(this);
     InitializeComponent();
     this.mouseState = new MouseStateOut(this);
 }

 //Should be called at beginning of Update in Game
 public static void Update()
 {
     oldKeyState = keyState;
     keyState = Keyboard.GetState();
     oldMouseState = mouseState;
     mouseState = Mouse.GetState();
 }

        public void Update(MouseState mouseState)
        {
            _previousFrameMouseState = _currentFrameMouseState;
            _currentFrameMouseState = mouseState;

            CalculateRelativeMousePosition();
        }

		public override void DoMouseInteraction(MouseState mouseState, System.Windows.Forms.MouseButtons mouseButtons, Vector2 mousePos, out bool shouldUpdate)
		{
			shouldUpdate = false;

			switch (mouseState)
			{
				case MouseState.ClickStart:
					if (Click == null)
					{
						Open();				
					}
					shouldUpdate = true; 					
					break;
				case MouseState.ClickEnd:
					if (Bounds.Contains(mousePos.X, mousePos.Y))
					{
						if (DoClick() == true)
						{
							Close();
						}
					}
					shouldUpdate = true; 
					break;
				default:
					base.DoMouseInteraction(mouseState, mouseButtons, mousePos, out shouldUpdate);
					break;
			}			
		}

 public void ClickOutput(AC.Menu _menu, MouseState _mouseState)
 {
     if (items.Count > 0)
     {
         if (_mouseState == MouseState.SingleClick)
         {
             if (KickStarter.runtimeInventory.selectedItem == null)
             {
                 // Pick up created item
                 if (activeRecipe.onCreateRecipe == OnCreateRecipe.SelectItem)
                 {
                     KickStarter.runtimeInventory.PerformCrafting (activeRecipe, true);
                 }
                 else if (activeRecipe.onCreateRecipe == OnCreateRecipe.RunActionList)
                 {
                     KickStarter.runtimeInventory.PerformCrafting (activeRecipe, false);
                     if (activeRecipe.invActionList != null)
                     {
                         AdvGame.RunActionListAsset (activeRecipe.invActionList);
                     }
                 }
                 else
                 {
                     KickStarter.runtimeInventory.PerformCrafting (activeRecipe, false);
                 }
             }
         }
         PlayerMenus.ResetInventoryBoxes ();
     }
 }

        public void HandleInput(MouseState mouseState, KeyboardState keyboardState)
        {
            KeyboardState = keyboardState;

            if (MouseOverRenderArea && mouseState.LeftButton == ButtonState.Pressed)
            {
                if (!MouseDragging)
                {
                    MouseDragging = true;
                    MousePreviousPosition = new Vector2(mouseState.X, mouseState.Y);
                }

                var mouseNewCoords = new Vector2(mouseState.X, mouseState.Y);

                MouseDelta.X = mouseNewCoords.X - MousePreviousPosition.X;
                MouseDelta.Y = mouseNewCoords.Y - MousePreviousPosition.Y;

                MousePreviousPosition = mouseNewCoords;
            }

            if (!MouseOverRenderArea || mouseState.LeftButton == ButtonState.Released)
            {
                MouseDragging = false;
            }
        }

 /// <summary>
 /// Initializes the input states
 /// </summary>
 public static void Initialize()
 {
     PreviousKeyboardState = CurrentKeyboardState =
         Keyboard.GetState();
     PreviousMouseState = CurrentMouseState =
         Mouse.GetState();
 }

        public void ClickContainer(MouseState _mouseState, int _slot, Container container)
        {
            if (container == null || KickStarter.runtimeInventory == null) return;

            KickStarter.runtimeInventory.SetFont (font, GetFontSize (), fontColor, textEffects);

            if (_mouseState == MouseState.SingleClick)
            {
                if (KickStarter.runtimeInventory.selectedItem == null)
                {
                    if (container.items.Count > (_slot+offset) && container.items [_slot+offset] != null)
                    {
                        ContainerItem containerItem = container.items [_slot + offset];
                        KickStarter.runtimeInventory.Add (containerItem.linkedID, containerItem.count, selectItemsAfterTaking, -1);
                        container.items.Remove (containerItem);
                    }
                }
                else
                {
                    // Placing an item inside the container
                    container.InsertAt (KickStarter.runtimeInventory.selectedItem, _slot+offset);
                    KickStarter.runtimeInventory.Remove (KickStarter.runtimeInventory.selectedItem);
                }
            }

            else if (_mouseState == MouseState.RightClick)
            {
                if (KickStarter.runtimeInventory.selectedItem != null)
                {
                    KickStarter.runtimeInventory.SetNull ();
                }
            }
        }

 public void Update()
 {
     previousMouseState = currentMouseState;
     previousKeyboardState = currentKeyboardState;
     currentMouseState = Mouse.GetState();
     currentKeyboardState = Keyboard.GetState();
 }

        // Method that check if our mouse input is over our button position.
        // if it is we change the color and the text.
        // when click we see the state to clicked.
        // finally check if any new events should be fired.
        internal void HandleInput(MouseState mouseState)
        {
            Sprite.Color = DefeaultSpriteColor;
            Text.Color = DefaultTextColor;

            if (ContainsPosition(new Vector2(mouseState.X, mouseState.Y)))
            {
                Sprite.Color = HoverSpriteColor;
                Text.Color = HoverTextColor;

                m_currentButtonState = ButtonState.Hovered;

                if(mouseState.LeftButton == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
                {
                    m_currentButtonState = ButtonState.Clicked;
                }
            }
            else
            {
                m_currentButtonState = ButtonState.None;
            }

            FireEvents();
            m_previousButtonState = m_currentButtonState;
        }

    public void Update(GameTime t)
    {
        this.PreviousKeyboardState = this.KeyboardState;
        this.PreviousMouseState = this.MouseState;

        this.KeyboardState = Keyboard.GetState();
        this.MouseState = Mouse.GetState();
    }

        /// <summary>
        /// Check input device without check Floor Height 
        /// </summary>
        public void Poll()
        {
            KeyState = KeyBoardDevice.GetCurrentKeyboardState();
            KeyBoardJOBs();

            MState = MouseDevice.CurrentMouseState;
            MouseJOBs();
        }

 public void OnMouseDown(IInputElement relativeTo, MouseButtonEventArgs e)
 {
     if (e.ChangedButton == MouseButton.Left && _selectionState == MouseState.WaitingForDown)
     {
         _selectionState = MouseState.WaitingForUp;
         _selectDown = e.GetPosition(relativeTo);
     }
 }

 public static void Update()
 {
     previousMouseState = currentMouseState;
     previousKeyboardState = currentKeyboardState;
     currentMouseState = Mouse.GetState();
     currentKeyboardState = Keyboard.GetState();
     DetermineScale();
 }

 /// <summary>
 /// Initializes a new instance of the Presenter class.
 /// </summary>
 /// <param name="view">View interface</param>
 /// <param name="factory">Path finder factory service</param>
 public Presenter(IView view, IPathFinderFactory factory)
 {
     this.View = view;
      this.View.Presenter = this;
      this.View.SetDrawing(this.Surface);
      this.CurrentMouseState = MouseState.Default;
      this.Factory = factory;
 }

        public MeasureTool(ImageCanvas canvas)
        {
            _lineOverlay = null;
            _mouseDownText = null;
            _mouseFollowText = null;

            _canvas = canvas;
            _mouseState = MouseState.WaitingForDown;
        }

 public InputSystem()
 {
     CurrentKeyboardState = new KeyboardState();
     PreviousKeyboardState = new KeyboardState();
     CurrentGamepadState = new GamePadState();
     PreviousGamepadState = new GamePadState();
     CurrentMouseState = new MouseState();
     PreviousMouseState = new MouseState();
 }

		public static MouseState GetState ()
		{
			MouseState ms = new MouseState(_x,_y);
			ms.LeftButton = _leftButton;
			ms.RightButton = _rightButton;
			ms.MiddleButton = _middleButton;
			
			return ms;
		}

 /// <summary>Update player inputs.</summary>
 public void Update()
 {
     previousMouseState = currentMouseState;
     previousKeyboardState = currentKeyboardState;
     previousControlerState = currentControlerState;
     currentMouseState = Mouse.GetState();
     currentKeyboardState = Keyboard.GetState();
     currentControlerState = GamePad.GetState(PlayerIndex.One);
 }