protected override bool PropagateMouseUp(IEnumerable <Drawable> drawables, InputState state, MouseUpEventArgs args) =>
 base.PropagateMouseUp(drawables, state, args) || handleNewReleased(state, KeyCombination.FromMouseButton(args.Button));
예제 #2
0
        protected override bool Handle(UIEvent e)
        {
            var state = e.CurrentState;

            switch (e)
            {
            case MouseDownEvent mouseDown:
                return(handleNewPressed(state, KeyCombination.FromMouseButton(mouseDown.Button)));

            case MouseUpEvent mouseUp:
                handleNewReleased(state, KeyCombination.FromMouseButton(mouseUp.Button));
                return(false);

            case KeyDownEvent keyDown:
                if (keyDown.Repeat)
                {
                    return(handleRepeat(state));
                }
                else
                {
                    return(handleNewPressed(state, KeyCombination.FromKey(keyDown.Key)));
                }

            case KeyUpEvent keyUp:
                handleNewReleased(state, KeyCombination.FromKey(keyUp.Key));
                return(false);

            case JoystickPressEvent joystickPress:
                return(handleNewPressed(state, KeyCombination.FromJoystickButton(joystickPress.Button)));

            case JoystickReleaseEvent joystickRelease:
                handleNewReleased(state, KeyCombination.FromJoystickButton(joystickRelease.Button));
                return(false);

            case MidiDownEvent midiDown:
                return(handleNewPressed(state, KeyCombination.FromMidiKey(midiDown.Key)));

            case MidiUpEvent midiUp:
                handleNewReleased(state, KeyCombination.FromMidiKey(midiUp.Key));
                return(false);

            case TabletPenButtonPressEvent tabletPenButtonPress:
                return(handleNewPressed(state, KeyCombination.FromTabletPenButton(tabletPenButtonPress.Button)));

            case TabletPenButtonReleaseEvent tabletPenButtonRelease:
                handleNewReleased(state, KeyCombination.FromTabletPenButton(tabletPenButtonRelease.Button));
                return(false);

            case TabletAuxiliaryButtonPressEvent tabletAuxiliaryButtonPress:
                return(handleNewPressed(state, KeyCombination.FromTabletAuxiliaryButton(tabletAuxiliaryButtonPress.Button)));

            case TabletAuxiliaryButtonReleaseEvent tabletAuxiliaryButtonRelease:
                handleNewReleased(state, KeyCombination.FromTabletAuxiliaryButton(tabletAuxiliaryButtonRelease.Button));
                return(false);

            case ScrollEvent scroll:
            {
                var  keys    = KeyCombination.FromScrollDelta(scroll.ScrollDelta);
                bool handled = false;

                foreach (var key in keys)
                {
                    handled |= handleNewPressed(state, key, scroll.ScrollDelta, scroll.IsPrecise);
                    handleNewReleased(state, key);
                }

                return(handled);
            }
            }

            return(false);
        }
 protected override bool PropagateMouseDown(IEnumerable <Drawable> drawables, InputState state, MouseDownEventArgs args) =>
 base.PropagateMouseDown(drawables, state, args) || handleNewPressed(state, KeyCombination.FromMouseButton(args.Button), false);
예제 #4
0
 protected override bool OnMouseUp(InputState state, MouseUpEventArgs args) => handleNewReleased(state, KeyCombination.FromMouseButton(args.Button));
예제 #5
0
 protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => handleNewPressed(state, KeyCombination.FromMouseButton(args.Button), false);
        protected override bool Handle(UIEvent e)
        {
            var state = e.CurrentState;

            switch (e)
            {
            case MouseDownEvent mouseDown:
                return(handleNewPressed(state, KeyCombination.FromMouseButton(mouseDown.Button), false));

            case MouseUpEvent mouseUp:
                handleNewReleased(state, KeyCombination.FromMouseButton(mouseUp.Button));
                return(false);

            case KeyDownEvent keyDown:
                if (keyDown.Repeat && !SendRepeats)
                {
                    return(pressedBindings.Count > 0);
                }

                foreach (var key in KeyCombination.FromKey(keyDown.Key))
                {
                    if (handleNewPressed(state, key, keyDown.Repeat))
                    {
                        return(true);
                    }
                }

                return(false);

            case KeyUpEvent keyUp:
                // this is releasing the common shift when a remaining shift is still held.
                // ie. press LShift, press RShift, release RShift will result in InputKey.Shift being incorrectly released.
                foreach (var key in KeyCombination.FromKey(keyUp.Key))
                {
                    handleNewReleased(state, key);
                }

                return(false);

            case JoystickPressEvent joystickPress:
                return(handleNewPressed(state, KeyCombination.FromJoystickButton(joystickPress.Button), false));

            case JoystickReleaseEvent joystickRelease:
                handleNewReleased(state, KeyCombination.FromJoystickButton(joystickRelease.Button));
                return(false);

            case MidiDownEvent midiDown:
                return(handleNewPressed(state, KeyCombination.FromMidiKey(midiDown.Key), false));

            case MidiUpEvent midiUp:
                handleNewReleased(state, KeyCombination.FromMidiKey(midiUp.Key));
                return(false);

            case TabletPenButtonPressEvent tabletPenButtonPress:
                return(handleNewPressed(state, KeyCombination.FromTabletPenButton(tabletPenButtonPress.Button), false));

            case TabletPenButtonReleaseEvent tabletPenButtonRelease:
                handleNewReleased(state, KeyCombination.FromTabletPenButton(tabletPenButtonRelease.Button));
                return(false);

            case TabletAuxiliaryButtonPressEvent tabletAuxiliaryButtonPress:
                return(handleNewPressed(state, KeyCombination.FromTabletAuxiliaryButton(tabletAuxiliaryButtonPress.Button), false));

            case TabletAuxiliaryButtonReleaseEvent tabletAuxiliaryButtonRelease:
                handleNewReleased(state, KeyCombination.FromTabletAuxiliaryButton(tabletAuxiliaryButtonRelease.Button));
                return(false);

            case ScrollEvent scroll:
            {
                var  keys    = KeyCombination.FromScrollDelta(scroll.ScrollDelta);
                bool handled = false;

                foreach (var key in keys)
                {
                    handled |= handleNewPressed(state, key, false, scroll.ScrollDelta, scroll.IsPrecise);
                    handleNewReleased(state, key);
                }

                return(handled);
            }
            }

            return(false);
        }
        protected override bool Handle(UIEvent e)
        {
            switch (e)
            {
            case MouseDownEvent mouseDown:
                return(handleNewPressed(KeyCombination.FromMouseButton(mouseDown.Button), false));

            case MouseUpEvent mouseUp:
                handleNewReleased(KeyCombination.FromMouseButton(mouseUp.Button));
                return(false);

            case KeyDownEvent keyDown:
                if (keyDown.Repeat && !SendRepeats)
                {
                    return(pressedBindings.Count > 0);
                }

                if (handleNewPressed(KeyCombination.FromKey(keyDown.Key), keyDown.Repeat))
                {
                    return(true);
                }

                return(false);

            case KeyUpEvent keyUp:
                handleNewReleased(KeyCombination.FromKey(keyUp.Key));
                return(false);

            case JoystickPressEvent joystickPress:
                return(handleNewPressed(KeyCombination.FromJoystickButton(joystickPress.Button), false));

            case JoystickReleaseEvent joystickRelease:
                handleNewReleased(KeyCombination.FromJoystickButton(joystickRelease.Button));
                return(false);

            case MidiDownEvent midiDown:
                return(handleNewPressed(KeyCombination.FromMidiKey(midiDown.Key), false));

            case MidiUpEvent midiUp:
                handleNewReleased(KeyCombination.FromMidiKey(midiUp.Key));
                return(false);

            case TabletPenButtonPressEvent tabletPenButtonPress:
                return(handleNewPressed(KeyCombination.FromTabletPenButton(tabletPenButtonPress.Button), false));

            case TabletPenButtonReleaseEvent tabletPenButtonRelease:
                handleNewReleased(KeyCombination.FromTabletPenButton(tabletPenButtonRelease.Button));
                return(false);

            case TabletAuxiliaryButtonPressEvent tabletAuxiliaryButtonPress:
                return(handleNewPressed(KeyCombination.FromTabletAuxiliaryButton(tabletAuxiliaryButtonPress.Button), false));

            case TabletAuxiliaryButtonReleaseEvent tabletAuxiliaryButtonRelease:
                handleNewReleased(KeyCombination.FromTabletAuxiliaryButton(tabletAuxiliaryButtonRelease.Button));
                return(false);

            case ScrollEvent scroll:
            {
                var  keys    = KeyCombination.FromScrollDelta(scroll.ScrollDelta);
                bool handled = false;

                foreach (var key in keys)
                {
                    handled |= handleNewPressed(key, false, scroll.ScrollDelta, scroll.IsPrecise);
                    handleNewReleased(key);
                }

                return(handled);
            }
            }

            return(false);
        }