/// <summary>
/// Handles watching the given key for
/// </summary>
/// <param name="myCurrentState"></param>
/// <param name="myPrevState"></param>
/// <param name="key"></param>
public void Watch(KeyboardState myCurrentState, KeyboardState myPrevState)
{
bool wasPressed = myPrevState.IsKeyDown(myKey);
bool isPressed = myCurrentState.IsKeyDown(myKey);
ButtonDelta deltaState =
isPressed != wasPressed ?
isPressed ? ButtonDelta.Pressed : ButtonDelta.Released :
isPressed ? ButtonDelta.Down : ButtonDelta.Up;
if (deltaState == ButtonDelta.Pressed)
{
OnPressed?.Invoke(this, new KeyPressEventArgs(myKey, deltaState));
}
if (deltaState == ButtonDelta.Released)
{
OnReleased?.Invoke(this, new KeyPressEventArgs(myKey, deltaState));
}
if (deltaState == ButtonDelta.Down)
{
OnDown?.Invoke(this, new KeyPressEventArgs(myKey, deltaState));
}
if (deltaState == ButtonDelta.Up)
{
OnUp?.Invoke(this, new KeyPressEventArgs(myKey, deltaState));
}
OnEvent?.Invoke(this, new KeyPressEventArgs(myKey, deltaState));
}
/// <summary>
/// Adds a new watch to the given key, only listening for the specified change
/// </summary>
/// <param name="key">The key to add the watch to</param>
/// <param name="listenState">The specific state change to listen to</param>
/// <param name="listener">The event listener that will listen for events</param>
public static void AddWatch(Keys key, ButtonDelta listenState, EventHandler <KeyPressEventArgs> listener)
{
if (!myWatches.ContainsKey(key))
{
myWatches.Add(key, new KeyListener(key));
}
myWatches[key][listenState] += listener;
}
/// <summary>
/// Adds a new event listener to the given mouse button, only listening for the given state
/// </summary>
/// <param name="button">The mouse button to listen to</param>
/// <param name="listenState">The specific state change to listen to</param>
/// <param name="listener">The event handler to handle events for this mouse button</param>
public static void AddWatch(MouseButton button, ButtonDelta listenState, EventHandler <DeltaMouseState> listener)
{
if (!myWatches.ContainsKey(button))
{
myWatches.Add(button, new MouseListener(button));
}
myWatches[button][listenState] += listener;
}
public void Watch(DeltaMouseState change)
{
ButtonDelta deltaState = ButtonDelta.Invalid;
switch (myButton)
{
case MouseButton.Left:
deltaState = change.LeftButton;
break;
case MouseButton.Right:
deltaState = change.RightButton;
break;
case MouseButton.Middle:
deltaState = change.MiddleButton;
break;
case MouseButton.XButton1:
deltaState = change.XButton1;
break;
case MouseButton.XButton2:
deltaState = change.XButton2;
break;
}
if (deltaState != ButtonDelta.Invalid)
{
if (deltaState == ButtonDelta.Pressed)
{
OnPressed?.Invoke(this, change);
}
if (deltaState == ButtonDelta.Released)
{
OnReleased?.Invoke(this, change);
}
if (deltaState == ButtonDelta.Down)
{
OnDown?.Invoke(this, change);
}
if (deltaState == ButtonDelta.Up)
{
OnUp?.Invoke(this, change);
}
OnEvent?.Invoke(this, change);
}
}
/// <summary>
/// Gets the event handler for the given button state
/// </summary>
/// <param name="button">The button state of the the event to get</param>
/// <returns>The event handler tied to the given button delta</returns>
public EventHandler <KeyPressEventArgs> this[ButtonDelta button]
{
get
{
switch (button)
{
case ButtonDelta.Pressed:
return(OnPressed);
case ButtonDelta.Released:
return(OnReleased);
case ButtonDelta.Down:
return(OnDown);
case ButtonDelta.Up:
return(OnUp);
default:
return(OnEvent);
}
}
set
{
switch (button)
{
case ButtonDelta.Pressed:
OnPressed = value;
break;
case ButtonDelta.Released:
OnReleased = value;
break;
case ButtonDelta.Down:
OnDown = value;
break;
case ButtonDelta.Up:
OnUp = value;
break;
default:
OnEvent = value;
break;
}
}
}
/// <summary>
/// Creates a new mouse delta state from two mouse states
/// </summary>
/// <param name="currentState">The mouse state of the most current frame</param>
/// <param name="prevState">The mouse state of the previous frame</param>
public DeltaMouseState(MouseState currentState, MouseState prevState, Vector2 smoothedPos, Vector2 smoothDelta)
{
X = currentState.X;
Y = currentState.Y;
DeltaX = currentState.X - prevState.X;
DeltaY = currentState.Y - prevState.Y;
SmoothedPosition = smoothedPos;
SmoothDeltaPosition = smoothDelta;
DoubleClicked = false;
LeftButton = currentState.LeftButton != prevState.LeftButton ? (ButtonDelta)currentState.LeftButton : currentState.LeftButton == ButtonState.Pressed ? ButtonDelta.Down : ButtonDelta.Up;
RightButton = currentState.RightButton != prevState.RightButton ? (ButtonDelta)currentState.RightButton : currentState.RightButton == ButtonState.Pressed ? ButtonDelta.Down : ButtonDelta.Up;
MiddleButton = currentState.MiddleButton != prevState.MiddleButton ? (ButtonDelta)currentState.MiddleButton : currentState.MiddleButton == ButtonState.Pressed ? ButtonDelta.Down : ButtonDelta.Up;
XButton1 = currentState.XButton1 != prevState.XButton1 ? (ButtonDelta)currentState.XButton1 : currentState.XButton1 == ButtonState.Pressed ? ButtonDelta.Down : ButtonDelta.Up;
XButton2 = currentState.XButton2 != prevState.XButton2 ? (ButtonDelta)currentState.XButton2 : currentState.XButton2 == ButtonState.Pressed ? ButtonDelta.Down : ButtonDelta.Up;
DeltaScroll = currentState.ScrollWheelValue - prevState.ScrollWheelValue;
}
/// <summary>
/// Creates a new key press event argument
/// </summary>
/// <param name="key">The keyboard key that the event is for</param>
/// <param name="deltaState">The delta state of the button</param>
public KeyPressEventArgs(Keys key, ButtonDelta deltaState)
{
Key = key;
DeltaState = deltaState;
}
/// <summary>
/// Creates a new key press event argument
/// </summary>
/// <param name="key">The keyboard key that the event is for</param>
/// <param name="newState">The current state of the button</param>
/// <param name="oldState">The state of the button at the last polling event</param>
public KeyPressEventArgs(Keys key, ButtonState newState, ButtonState oldState)
{
Key = key;
DeltaState = newState != oldState ? (ButtonDelta)newState : newState == ButtonState.Pressed ? ButtonDelta.Down : ButtonDelta.Up;
}
/// <summary>
/// Creates an empty key press event argument
/// </summary>
public KeyPressEventArgs()
{
Key = Keys.None;
DeltaState = ButtonDelta.Released;
}
