Esempio n. 1
0
 public MouseButtonEventArgs(MouseButton button, bool pressed, int x, int y)
 {
     this.button = button;
     this.pressed = pressed;
     this.x = x;
     this.y = y;
 }
Esempio n. 2
0
 public static void SimulateMouseEvent(MouseButton button, MouseButtonState state)
 {
     uint x = 0;
     uint y = 0;
     switch (button)
     {
         case MouseButton.Left:
             if (state == MouseButtonState.Pressed)
                 mouse_event(MOUSEEVENTF_LEFTDOWN, x, y, 0, 0);
             else
                 mouse_event(MOUSEEVENTF_LEFTUP, x, y, 0, 0);
             break;
         case MouseButton.Middle:
             if (state == MouseButtonState.Pressed)
                 mouse_event(MOUSEEVENTF_MIDDLEDOWN, x, y, 0, 0);
             else
                 mouse_event(MOUSEEVENTF_MIDDLEUP, x, y, 0, 0);
             break;
         case MouseButton.Right:
             if (state == MouseButtonState.Pressed)
                 mouse_event(MOUSEEVENTF_RIGHTDOWN, x, y, 0, 0);
             else
                 mouse_event(MOUSEEVENTF_RIGHTUP, x, y, 0, 0);
             break;
     }
 }
Esempio n. 3
0
        public bool IsButtonClicked(MouseButton button)
        {
            ButtonState lastBtnStat = ButtonState.Released;
            ButtonState curBtnStat = ButtonState.Released;

            switch (button)
            {
                case MouseButton.Left:
                    lastBtnStat = lastMouseState.LeftButton;
                    curBtnStat = curMouseState.LeftButton;
                    break;
                case MouseButton.Right:
                    lastBtnStat = lastMouseState.RightButton;
                    curBtnStat = curMouseState.RightButton;
                    break;
                case MouseButton.Middle:
                    lastBtnStat = lastMouseState.MiddleButton;
                    curBtnStat = curMouseState.MiddleButton;
                    break;
                case MouseButton.X1:
                    lastBtnStat = lastMouseState.XButton1;
                    curBtnStat = curMouseState.XButton2;
                    break;
                case MouseButton.X2:
                    lastBtnStat = lastMouseState.XButton2;
                    curBtnStat = curMouseState.XButton2;
                    break;
            }

            if (lastBtnStat == ButtonState.Pressed &&
                curBtnStat == ButtonState.Released)
                return true;
            return false;
        }
Esempio n. 4
0
 /// <summary>
 ///     Gets the current state of the specified button from the device from either the underlying system or the StylusDevice
 /// </summary>
 /// <param name="mouseButton">
 ///     The mouse button to get the state of
 /// </param>
 /// <returns>
 ///     The state of the specified mouse button
 /// </returns>
 protected MouseButtonState GetButtonState(MouseButton mouseButton)
 {
     if ( _stylusDevice != null )
         return _stylusDevice.GetMouseButtonState(mouseButton, this);
     else
         return GetButtonStateFromSystem(mouseButton);
 }
Esempio n. 5
0
 public override void OnMouseDrag(float x, float y, float dx, float dy, MouseButton button, List<ModifierKey> modifiers)
 {
     if (HasFocus)
         Focus.OnMouseDrag(x, y, dx, dy, button, modifiers);
     else
         base.OnMouseDrag(x, y, dx, dy, button, modifiers);
 }
Esempio n. 6
0
 public MouseEventArgs(int button, Vector2 location, int clicks)
 {
     this.Button = (MouseButton)button;
         this.Clicks = clicks;
         this.Location = new Point(location);
         this.Delta = 0;
 }
        public PlainSurfaceItem(int maxWidth, int maxHeight, int widthRequest = 0, int heightRequest = 0, string label = null)
        {
            //Console.WriteLine ("PlainSurfaceItem");
            _label = label;
            this._evtBox = new EventBox ();
            this._draw = new global::Gtk.DrawingArea ();
            if(widthRequest > 0) {
                _draw.WidthRequest = widthRequest;
            }
            if(heightRequest > 0) {
                _draw.HeightRequest = heightRequest;
            }

            this._evtBox.Add (this._draw);

            maxWidth = Math.Max (maxWidth, widthRequest);
            maxHeight = Math.Max (maxHeight, heightRequest);
            this._height = Math.Max(_draw.Allocation.Height, heightRequest);
            this._width = Math.Max(_draw.Allocation.Width, widthRequest);
            this._mode = DisplayMode.Snapshot;
            this._surface = new ImageSurface(Format.Argb32, maxWidth, maxHeight);
            this._button = MouseButton.None;
            this._background = new Color (1.0, 1.0, 1.0);

            _draw.ExposeEvent += DrawExpose;
            _evtBox.ButtonPressEvent += DrawButtonPressEvent;
            _evtBox.ButtonReleaseEvent += DrawButtonReleaseEvent;
            _evtBox.MotionNotifyEvent += DrawMotionNotifyEvent;
        }
Esempio n. 8
0
 public override void MouseClick(MouseButton button)
 {
     if (button == MouseButton.Left)
     {
         //switch (mainMenu.SelectedOption)
         //{
         //    case MainMenuFunction.NewGame:
         //        Game.NewGame();
         //        break;
         //    case MainMenuFunction.LoadGame:
         //        Game.StartTransition(GameState.LoadGame);
         //        break;
         //    case MainMenuFunction.Help:
         //        Game.StartTransition(GameState.Help);
         //        break;
         //    case MainMenuFunction.Exit:
         //        //Exit();
         //        break;
         //    case MainMenuFunction.GameStats:
         //        Game.StartTransition(GameState.GameStatsHelp);
         //        break;
         //    default:
         //        break;
         //}
     }
 }
Esempio n. 9
0
        public InputAxisMap(MouseButton button)
        {
            TriggerType = AxisType.Mouse;
            Trigger = button;

            SecondTriggerType = AxisType.None;
        }
Esempio n. 10
0
        private void CheckButtonPressed(Func<MouseState, ButtonState> getButtonState, MouseButton button)
        {
            if (getButtonState(_currentState) == ButtonState.Pressed && 
                getButtonState(_previousState) == ButtonState.Released)
            {
                var args = new MouseEventArgs(_gameTime.TotalGameTime, _previousState, _currentState, button);

                MouseDown.Raise(this, args);
                _mouseDownArgs = args;

                if (_previousClickArgs != null)
                {
                    // If the last click was recent
                    var clickMilliseconds = (args.Time - _previousClickArgs.Time).TotalMilliseconds;

                    if (clickMilliseconds <= DoubleClickMilliseconds)
                    {
                        MouseDoubleClicked.Raise(this, args);
                        _hasDoubleClicked = true;
                    }

                    _previousClickArgs = null;
                }
            }
        }
Esempio n. 11
0
        private void CheckButtonReleased(Func<MouseState, ButtonState> getButtonState, MouseButton button)
        {
            if (getButtonState(_currentState) == ButtonState.Released &&
                getButtonState(_previousState) == ButtonState.Pressed)
            {
                var args = new MouseEventArgs(_gameTime.TotalGameTime, _previousState, _currentState, button);
                
                if (_mouseDownArgs.Button == args.Button)
                {
                    var clickMovement = DistanceBetween(args.Position, _mouseDownArgs.Position);

                    // If the mouse hasn't moved much between mouse down and mouse up
                    if (clickMovement < DragThreshold)
                    {
                        if(!_hasDoubleClicked)
                            MouseClicked.Raise(this, args);
                    }
                    else // If the mouse has moved between mouse down and mouse up
                    {
                        MouseDragged.Raise(this, args);
                    }
                }

                MouseUp.Raise(this, args);

                _hasDoubleClicked = false;
                _previousClickArgs = args;
            }
        }
Esempio n. 12
0
 public MouseClickEntityEventArgs(int x, int y, MouseButton mouseButton, bool justClicked, bool doubleClicked)
     : base(x, y)
 {
     MouseButton = mouseButton;
     JustClicked = justClicked;
     DoubleClicked = doubleClicked;
 }
Esempio n. 13
0
        internal override MouseButtonState GetButtonStateFromSystem(MouseButton mouseButton)
        {
            MouseButtonState mouseButtonState = MouseButtonState.Released;

            // Security Mitigation: do not give out input state if the device is not active.
            if(IsActive)
            {
                int virtualKeyCode = 0;

                switch( mouseButton )
                {
                    case MouseButton.Left:
                        virtualKeyCode = NativeMethods.VK_LBUTTON;
                        break;
                    case MouseButton.Right:
                        virtualKeyCode = NativeMethods.VK_RBUTTON;
                        break;
                    case MouseButton.Middle:
                        virtualKeyCode = NativeMethods.VK_MBUTTON;
                        break;
                    case MouseButton.XButton1:
                        virtualKeyCode = NativeMethods.VK_XBUTTON1;
                        break;
                    case MouseButton.XButton2:
                        virtualKeyCode = NativeMethods.VK_XBUTTON2;
                        break;
                }

                mouseButtonState = ( UnsafeNativeMethods.GetKeyState(virtualKeyCode) & 0x8000 ) != 0 ? MouseButtonState.Pressed : MouseButtonState.Released;
            }

            return mouseButtonState;
        }
Esempio n. 14
0
 public CodeBoundMouse(Action a, MouseButton button, bool pressing = true, bool constant = false)
 {
     Lambda = a;
     BoundMouseButton = button;
     Press = pressing;
     Constant = (pressing) && constant;
 }
 private void ProcessMouseButton(MouseButton mouseButton)
 {
     if(_actionEvaluator.ShouldButtonActionBeFired(mouseButton))
     {
         FireMouseAction(mouseButton);
     }
 }
Esempio n. 16
0
 protected void ntfyMouseDown(MouseButton btn, int x, int y)
 {
     if (onMouseDown != null)
     {
         onMouseDown.Invoke(btn, x, y);
     }
 }
Esempio n. 17
0
 protected void ntfyMouseMove(MouseButton btn, int x, int y)
 {
     if (onMouseMove != null)
     {
         onMouseMove.Invoke(btn, x, y);
     }
 }
Esempio n. 18
0
 /// <summary>
 /// Handles the <see cref="Mouse.PreviewMouseDownEvent"/>.
 /// </summary>
 private static void HandlePreviewMouseDown(DependencyObject element, MouseDevice device, MouseButton button, ref RoutedEventData data)
 {
     if (button == MouseButton.Left)
     {
         ((SliderBase)element).Focus();
     }
 }
Esempio n. 19
0
		public override void Reset()
		{
			button = MouseButton.Left;
			sendEvent = null;
			storeResult = null;
		    inUpdateOnly = true;
		}
Esempio n. 20
0
        internal static bool TryClickOnBoundingRectangleCenter(
            MouseButton button, 
            CruciatusElement element, 
            bool doubleClick)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            Point point;
            if (!AutomationElementHelper.TryGetBoundingRectangleCenter(element.Instance, out point))
            {
                Logger.Debug("Element '{0}' have empty BoundingRectangle", element);
                return false;
            }

            if (doubleClick)
            {
                CruciatusFactory.Mouse.DoubleClick(button, point.X, point.Y);
            }
            else
            {
                CruciatusFactory.Mouse.Click(button, point.X, point.Y);
            }

            Logger.Info(
                "{0} on '{1}' element at ({2}, {3}) BoundingRectangle center", 
                doubleClick ? "DoubleClick" : "Click", 
                element, 
                point.X, 
                point.Y);
            return true;
        }
Esempio n. 21
0
 public GenericSelectTarget(IEnumerable<Actor> subjects, string order, string cursor, MouseButton button)
 {
     this.subjects = subjects;
     this.order = order;
     this.cursor = cursor;
     expectedButton = button;
 }
Esempio n. 22
0
 // eliminar esto
 public void RaiseButtonClickEvent(Control source, MouseButton button, int index)
 {
     if (this.ButtonClick != null)
     {
         this.ButtonClick(source, new ToolClickEventArgs(button, this, index));
     }
 }
Esempio n. 23
0
		public GenericSelectTarget(IEnumerable<Actor> subjects, string order, string cursor, MouseButton button)
		{
			Subjects = subjects;
			OrderName = order;
			Cursor = cursor;
			ExpectedButton = button;
		}
Esempio n. 24
0
		public MouseHoldTrigger(Rectangle holdArea, float holdTime = DefaultHoldTime,
			MouseButton button = MouseButton.Left)
		{
			HoldArea = holdArea;
			HoldTime = holdTime;
			Button = button;
		}
Esempio n. 25
0
        public bool IsMouseButtonPressed(Player player, MouseButton button)
        {
            if (player.InputType != InputType.Mouse)
                return false;

            return Sources[player].IsMouseButtonPressed(button);
        }
Esempio n. 26
0
 private void SetButtonStateTo(MouseButton button, SharpDX.Toolkit.Input.ButtonState state)
 {
     switch (button)
     {
         case MouseButton.None:
             break;
         case MouseButton.Left:
             left = state;
             break;
         case MouseButton.Middle:
             middle = state;
             break;
         case MouseButton.Right:
             right = state;
             break;
         case MouseButton.XButton1:
             xButton1 = state;
             break;
         case MouseButton.XButton2:
             xButton2 = state;
             break;
         default:
             throw new ArgumentOutOfRangeException("button");
     }
 }
Esempio n. 27
0
        // Event raised on mouse down in the ZoomAndPanControl
        public static void MouseDown(object sender, MouseButtonEventArgs e,Panel p, ZoomAndPanControl z)
        {
            p.Focus();
            Keyboard.Focus(p);

            mouseButtonDown = e.ChangedButton;
            origZoomAndPanControlMouseDownPoint = e.GetPosition(z);
            origContentMouseDownPoint = e.GetPosition(p);

            if ((Keyboard.Modifiers & ModifierKeys.Shift) != 0 &&
                (e.ChangedButton == MouseButton.Left ||
                 e.ChangedButton == MouseButton.Right))
            {
                // Shift + left- or right-down initiates zooming mode.
                mouseHandlingMode = MouseHandlingMode.Zooming;
            }
            else if (mouseButtonDown == MouseButton.Left)
            {
                // Just a plain old left-down initiates panning mode.
                mouseHandlingMode = MouseHandlingMode.Panning;
            }

            if (mouseHandlingMode != MouseHandlingMode.None)
            {
                // Capture the mouse so that we eventually receive the mouse up event.
                z.CaptureMouse();
                e.Handled = true;
            }
        }
Esempio n. 28
0
 public MouseButtonEventArgs(RoutedEvent routedEvent, object originalSource, MouseDevice mouseDevice, int timestamp, Point absolutePosition, MouseButton changedButton, MouseButtonState buttonState, int clickCount)
     : base(routedEvent, originalSource, mouseDevice, timestamp, absolutePosition)
 {
     this.ChangedButton = changedButton;
     this.ButtonState = buttonState;
     this.ClickCount = clickCount;
 }
Esempio n. 29
0
 public override void MouseDown(MouseButton button, Vec2 pos)
 {
     base.MouseDown(button, pos);
     foreach (var b in buttons)
         if (b.Selected)
             b.Action.Apply();
 }
Esempio n. 30
0
 public override void OnMouseButtonPressed(MouseButton button, float x, float y)
 {
     var node = World.Find ("Sender");
     if (node != null) {
         node.GetComponent<MySender> ().Address = address;
     }
 }
Esempio n. 31
0
 /// <summary>
 /// Get if mouse button was pressed on this frame.
 /// </summary>
 /// <param name="button">Mouse button to test.</param>
 /// <returns>If mouse button was pressed this frame.</returns>
 public bool MousePressed(MouseButton button = MouseButton.Left)
 {
     return(_input.MouseButtonPressed((UI.MouseButton)button));
 }
 /// <summary>
 ///  Creates new mouse button event data.
 /// </summary>
 /// <param name="x">The X coordinate for the event.</param>
 /// <param name="y">The Y coordinate for the event.</param>
 /// <param name="button">The mouse button for the event.</param>
 /// <param name="isPressed">Whether the button was pressed or released.</param>
 public MouseButtonEventArgs(int x, int y, MouseButton button, bool isPressed)
     : base(x, y)
 {
     Button    = button;
     IsPressed = isPressed;
 }
Esempio n. 33
0
 /// <summary>
 /// Assign a mouse button to a Game key.
 /// </summary>
 /// <param name="mouseButton">Mouse button.</param>
 /// <param name="gameKey">Game key.</param>
 public void AssignMouseButtonToGameKey(MouseButton mouseButton, GameKeys gameKey)
 {
     _mouseKeysMap[mouseButton] = gameKey;
 }
Esempio n. 34
0
 private void RaisePressedEvent(ListBox listBox, ListBoxItem item, MouseButton mouseButton)
 {
     _mouse.Click(listBox, item, mouseButton);
 }
Esempio n. 35
0
 /// <summary>
 /// Get if mouse button is currently down.
 /// </summary>
 /// <param name="button">Mouse button to test.</param>
 /// <returns>If mouse button is down.</returns>
 public bool IsMouseButtonDown(MouseButton button = MouseButton.Left)
 {
     return(_input.MouseButtonDown((UI.MouseButton)button));
 }
Esempio n. 36
0
 static void widget_EventMouseButtonPressed(Widget _sender, int _left, int _top, MouseButton _id)
 {
     Gui.Instance.Log("TestApp", LogLevel.Info, "EventMouseButtonPressed  _left=" + _left.ToString() + "   _top=" + _top.ToString() + "   _id=" + _id.ToString());
 }
Esempio n. 37
0
 public void MouseDown(MouseButton button) => SetInputState(new InputEventArgs()
 {
     Type = InputEventType.MouseDown, Button = button
 });
Esempio n. 38
0
 public void Use(MouseButton button, Action <MouseButton> onButtonUp)
 {
     m_buttonUpListeners[(int)button] = onButtonUp;
 }
Esempio n. 39
0
 /// <summary>
 ///     Gets the current state of the specified button
 /// </summary>
 /// <param name="mouseButton">
 ///     The mouse button to get the state of
 /// </param>
 /// <param name="mouseDevice">
 ///     The MouseDevice that is making the request
 /// </param>
 /// <returns>
 ///     The state of the specified mouse button
 /// </returns>
 /// <remarks>
 ///     This is the hook where the Input system (via the MouseDevice) can call back into
 ///     the Stylus system when we are processing Stylus events instead of Mouse events
 /// </remarks>
 internal abstract MouseButtonState GetMouseButtonState(MouseButton mouseButton, MouseDevice mouseDevice);
Esempio n. 40
0
 public Clicked(Event e, MouseButton mouseButton)
 {
     this.e           = e;
     this.mouseButton = mouseButton;
 }
Esempio n. 41
0
 public static bool GetMouseButton(GlfwWindowPtr window, MouseButton button)
 {
     return(GlfwDelegates.glfwGetMouseButton(window, button) != 0);
 }
Esempio n. 42
0
        private void On_Dblclick_Backpack(AControl control, int x, int y, MouseButton button)
        {
            Container backpack = ((Mobile)m_sourceEntity).Backpack;

            m_World.Interaction.DoubleClick(backpack);
        }
Esempio n. 43
0
 protected MouseButtonEventManager(MouseButton button)
 {
     Button = button;
 }
Esempio n. 44
0
 internal void MouseUp(MouseButton button)
 {
     leftDown  = button.HasFlag(MouseButton.Left);
     rightDown = button.HasFlag(MouseButton.Right);
 }
Esempio n. 45
0
        private void HandleMessage(string message)
        {
            var msg = JSONNode.Parse(message);


            switch ((string)msg["type"])
            {
            case "mouseDown":
            case "mouseUp": {
                int         button = msg["button"];
                MouseButton flag   = 0;
                if (button == 0)
                {
                    flag = MouseButton.Left;
                }
                else if (button == 1)
                {
                    flag = MouseButton.Right;
                }
                else if (button == 2)
                {
                    flag = MouseButton.Middle;
                }

                if (msg["type"] == "mouseDown")
                {
                    MouseButtons |= flag;
                }
                else
                {
                    MouseButtons &= ~flag;
                }

                break;
            }

            case "mouseMove": {
                var screenPos = new Vector2(msg["x"], msg["y"]);
                screenPos.x   = screenPos.x / browser.Size.x;
                screenPos.y   = screenPos.y / browser.Size.y;
                MousePosition = screenPos;
                //Debug.Log("mouse now at " + screenPos);
                break;
            }

            case "mouseFocus":
                MouseHasFocus = msg["focus"];
                break;

            case "keyboardFocus":
                KeyboardHasFocus = msg["focus"];
                break;

            case "mouseScroll": {
                const float mult = 1 / 3f;
                MouseScroll += new Vector2(msg["x"], msg["y"]) * mult;
                break;
            }

            case "keyDown":
            case "keyUp": {
                var ev = new Event();
                ev.type      = msg["type"] == "keyDown" ? EventType.KeyDown : EventType.KeyUp;
                ev.character = (char)0;
                ev.keyCode   = KeyMappings.GetUnityKeyCode(msg["code"]);
                SetMods(ev);

                //Debug.Log("Convert wkc " + (int)msg["code"] + " to ukc " + ev.keyCode);

                KeyEvents.Add(ev);
                break;
            }

            case "keyPress": {
                string characters = msg["characters"];
                foreach (char c in characters)
                {
                    var ev = new Event();
                    ev.type = EventType.KeyDown;
                    SetMods(ev);
                    ev.character = c;
                    ev.keyCode   = 0;

                    KeyEvents.Add(ev);
                }
                break;
            }

            case "resize":
                //on OS X (editor at least), resizing hangs the update loop, so we suddenly end up with a bajillion resize
                //messages we were unable to process. Just record it here and when we've processed everything we'll resize
                delayedResize.x = msg["w"];
                delayedResize.y = msg["h"];
                break;

            case "close":
                Destroy(gameObject);
                break;

            default:
                Debug.LogWarning("Unknown window event: " + msg.AsJSON);
                break;
            }
        }
Esempio n. 46
0
 public bool IsButtonUp(MouseButton button)
 {
     return(!IsButtonDown(button));
 }
        public void NotifyListItemClicked(NavigateMenuItem item, MouseButton mouseButton)
        {
            if (mouseButton == MouseButton.Left && Mouse.Captured != this)
            {
                Mouse.Capture(this, CaptureMode.SubTree);
                //base.SetInitialMousePosition();
            }

            if (!item.IsSelected)
            {
                item.SetCurrentValue(Selector.IsSelectedProperty, true);
            }
            else if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
            {
                item.SetCurrentValue(Selector.IsSelectedProperty, false);
            }
            //this.UpdateAnchorAndActionItem(base.ItemInfoFromContainer(item));
            return;

            //switch (this.SelectionMode)
            //{
            //    case SelectionMode.Single:
            //        if (!item.IsSelected)
            //        {
            //            item.SetCurrentValue(Selector.IsSelectedProperty, true);
            //        }
            //        else if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
            //        {
            //            item.SetCurrentValue(Selector.IsSelectedProperty, false);
            //        }
            //        //this.UpdateAnchorAndActionItem(base.ItemInfoFromContainer(item));
            //        return;
            //case SelectionMode.Multiple:
            //    this.MakeToggleSelection(item);
            //    return;
            //case SelectionMode.Extended:
            //    if (mouseButton != MouseButton.Left)
            //    {
            //        if (mouseButton == MouseButton.Right && (Keyboard.Modifiers & (ModifierKeys.Control | ModifierKeys.Shift)) == ModifierKeys.None)
            //        {
            //            if (item.IsSelected)
            //            {
            //                this.UpdateAnchorAndActionItem(base.ItemInfoFromContainer(item));
            //                return;
            //            }
            //            this.MakeSingleSelection(item);
            //        }
            //        return;
            //    }
            //    if ((Keyboard.Modifiers & (ModifierKeys.Control | ModifierKeys.Shift)) == (ModifierKeys.Control | ModifierKeys.Shift))
            //    {
            //        this.MakeAnchorSelection(item, false);
            //        return;
            //    }
            //    if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
            //    {
            //        this.MakeToggleSelection(item);
            //        return;
            //    }
            //    if ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
            //    {
            //        this.MakeAnchorSelection(item, true);
            //        return;
            //    }
            //    this.MakeSingleSelection(item);
            //    return;
            //default:
            //    return;
            //}
        }
 public GuardOrderGenerator(IEnumerable <Actor> subjects, string order, string cursor, MouseButton button)
     : base(subjects, order, cursor, button)
 {
 }
Esempio n. 49
0
 public virtual bool HandlesMouseUp(int mouseX, int mouseY, MouseButton button)
 {
     return(false);
 }
Esempio n. 50
0
 public static void Click(MouseButton button)
 {
     Down(button);
     Up(button);
 }
Esempio n. 51
0
 public bool IsButtonDown(MouseButton button)
 {
     return(mouseButtons[(int)button]);
 }