private Key?GetKey(SDL_Keycode key)
{
if (key >= SDL_Keycode.SDLK_a && key <= SDL_Keycode.SDLK_z)
{
return(Key.a + (key - SDL_Keycode.SDLK_a));
}
if (key >= SDL_Keycode.SDLK_0 && key <= SDL_Keycode.SDLK_9)
{
return(Key.ZERO + (key - SDL_Keycode.SDLK_0));
}
switch (key)
{
case SDL_Keycode.SDLK_LSHIFT:
case SDL_Keycode.SDLK_RSHIFT:
return(Key.SHIFT);
case SDL_Keycode.SDLK_LCTRL:
case SDL_Keycode.SDLK_RCTRL:
return(Key.CTRL);
case SDL_Keycode.SDLK_SPACE:
return(Key.SPACE);
default:
return(null);
}
}
public static void SetKeyDown(SDL_Keycode keycode)
{
_logger.LogInfo("SetKeyDown " + keycode);
switch (keycode)
{
case SDL_Keycode.SDLK_a:
A = true;
if (ADownLock == false)
{
ADown = true;
ADownLock = true;
}
break;
case SDL_Keycode.SDLK_d: D = true; break;
case SDL_Keycode.SDLK_w: W = true; break;
case SDL_Keycode.SDLK_s: S = true; break;
case SDL_Keycode.SDLK_LSHIFT: LeftShift = true; break;
default: break;
}
}
/// <summary>
/// Checks if key was let up after being pressed this frame.
/// </summary>
/// <param name="key">The key to check.</param>
/// <returns>True if key was let up this frame. False if key is down.</returns>
public static bool KeyUp(SDL_Keycode key)
{
if (keyUpList.Contains(key))
{
return(true);
}
return(false);
}
private void UpdateDataSwitches(SDL_Keycode sdlKey, bool keyDown)
{
if (_sdlVKeymap.ContainsKey(sdlKey))
{
VKeys virtualKey = _sdlVKeymap[sdlKey];
//
// If this is a key mapped to a front panel switch
// we will toggle the bit in the DS register based on whether
// the key is down or up and the specified mapping mode.
//
for (int i = 0; i < 16; i++)
{
if (_dataSwitchMappings[i] == VKeys.None0)
{
_dataSwitches &= ~(0x1 << (15 - i));
}
else if (_dataSwitchMappings[i] == VKeys.None1)
{
_dataSwitches |= (0x1 << (15 - i));
}
else if (virtualKey == _dataSwitchMappings[i])
{
switch (_dataSwitchMappingMode)
{
case DataSwitchMappingMode.Momentary:
case DataSwitchMappingMode.MomentaryInverted:
if (_dataSwitchMappingMode == DataSwitchMappingMode.MomentaryInverted)
{
// Invert the sense
keyDown = !keyDown;
}
// toggle this bit
if (keyDown)
{
// or it in
_dataSwitches |= (0x1 << (15 - i));
}
else
{
// mask it out
_dataSwitches &= ~(0x1 << (15 - i));
}
break;
case DataSwitchMappingMode.Toggle:
if (keyDown)
{
// toggle it
_dataSwitches ^= (0x1 << (15 - i));
}
break;
}
}
}
}
}
protected override void OnKeyEvent(SDL_Keycode key, bool pressed, bool isRepeat)
{
if (!isRepeat || RepeatAllowedKeys.Contains(key))
{
base.OnKeyEvent(key, pressed, isRepeat);
}
ControlStates[(int)Controls.COPY] = !isRepeat && (key == SDL_Keycode.SDLK_c && IsControlKeyPressed());
ControlStates[(int)Controls.PASTE] = !isRepeat && (key == SDL_Keycode.SDLK_v && IsControlKeyPressed());
}
private ImlacKey TranslateKeyCode(SDL_Keycode virtualKey)
{
if (_sdlImlacKeymap.ContainsKey(virtualKey))
{
return(_sdlImlacKeymap[virtualKey]);
}
else
{
return(ImlacKey.Invalid);
}
}
public bool IsDown(SDL_Keycode key)
{
if (_keys.TryGetValue(key, out bool result))
{
return(result);
}
else
{
return(false);
}
}
protected virtual void OnKeyEvent(SDL_Keycode key, bool pressed, bool isRepeat)
{
var intKey = (int)key;
if (ControlsByKeys.ContainsKey(intKey))
{
if (AllowRepeats || !isRepeat)
ControlStates[ControlsByKeys[intKey]] = pressed;
HandleToggleMusic();
}
}
public static bool IsKeyDown(SDL_Keycode key)
{
if (keysDown.Contains(key))
{
return(true);
}
else
{
return(false);
}
}
public static bool KeyUp(SDL_Keycode key)
{
foreach (var k in _keyEvents)
{
if (k.key.keysym.sym == key)
{
return(true);
}
}
return(false);
}
private void SdlKeyDown(SDL_Keycode key, bool repeat)
{
switch (key)
{
case SDL_Keycode.SDLK_LSHIFT:
case SDL_Keycode.SDLK_RSHIFT:
_keyModifiers |= ImlacKeyModifiers.Shift;
break;
case SDL_Keycode.SDLK_LCTRL:
case SDL_Keycode.SDLK_RCTRL:
_keyModifiers |= ImlacKeyModifiers.Ctrl;
break;
case SDL_Keycode.SDLK_LALT:
case SDL_Keycode.SDLK_RALT:
_keyModifiers |= ImlacKeyModifiers.Rept;
break;
default:
UpdateDataSwitches(key, true /* key down */);
if (key == SDL_Keycode.SDLK_INSERT && !repeat)
{
FullScreenToggle();
break;
}
// If this is a repeated keystroke, we'll only log it if
// the Repeat key (Alt) is being held down.
if (repeat && (_keyModifiers & ImlacKeyModifiers.Rept) == 0)
{
break;
}
_keyLatchedLock.EnterWriteLock();
if (!_keyLatched)
{
ImlacKey newCode = TranslateKeyCode(key);
// Only latch valid keys.
if (newCode != ImlacKey.Invalid)
{
_keyLatched = true;
_latchedKeyCode = newCode;
}
}
_keyLatchedLock.ExitWriteLock();
break;
}
}
public static bool IsKeyPressed(SDL_Keycode key)
{
if (keysDown.Contains(key) && !keysPressed.Contains(key))
{
keysPressed.Add(key);
return(true);
}
else
{
return(false);
}
}
public bool IsDown(SDL_Keycode key)
{
//if (!_keys.ContainsKey(key)) return false;
if (_keys.TryGetValue(key, out bool result))
{
return(result);
}
else
{
return(false);
}
}
public static bool IsKeyPressed(char key)
{
SDL_Keycode sym = (SDL_Keycode)key;
if (keysDown.Contains(sym) && !keysPressed.Contains(sym))
{
keysPressed.Add(sym);
return(true);
}
else
{
return(false);
}
}
public bool HandleKeybaordEvent(KeyboardEvent type, SDL_Keycode key, bool shift, bool alt, bool ctrl)
{
foreach (InputEvent e in _events)
{
if (!e.IsHandled && e is InputKeyboardEvent ke && ke.EventType == type && ke.KeyCode == key && ke.Shift == shift && ke.Alt == alt && ke.Control == ctrl)
{
e.IsHandled = true;
return(true);
}
}
return(false);
}
public static void Register(SDL_Keycode code, bool value)
{
long key = Convert.ToInt64(code);
if (value)
{
if (!KeysDown.Contains(key))
{
KeysDown.Add(key);
}
}
else
{
KeysDown.Remove(key);
}
}
private void OnKeyDown(InputKeyboardEvent e)
{
if (_lastKey == SDL_Keycode.SDLK_LCTRL && e.KeyCode == SDL_Keycode.SDLK_v)
{
OnTextInput(new InputKeyboardEvent(KeyboardEvent.TextInput, SDL_Keycode.SDLK_UNKNOWN, 0, SDL_Keymod.KMOD_NONE)
{
KeyChar = SDL_GetClipboardText()
});
}
else
{
if (_lastKey == e.KeyCode && _lastKey != SDL_Keycode.SDLK_UNKNOWN || e.EventType == KeyboardEvent.Down)
{
AddEvent(new InputKeyboardEvent(KeyboardEvent.Press, e));
}
_lastKey = e.KeyCode;
AddEvent(e);
}
}
public static void HandleInput(SDL_Keycode key, bool state)
{
if (state)
{
if (!keysDown.Contains(key))
{
keysDown.Add(key);
}
}
else
{
if (keysDown.Contains(key))
{
keysDown.Remove(key);
}
if (keysPressed.Contains(key))
{
keysPressed.Remove(key);
}
}
}
public static void SetKeyUp(SDL_Keycode keycode)
{
switch (keycode)
{
case SDL_Keycode.SDLK_a:
A = false;
AUp = true;
ADownLock = false;
break;
case SDL_Keycode.SDLK_d: D = false; break;
case SDL_Keycode.SDLK_w: W = false; break;
case SDL_Keycode.SDLK_s: S = false; break;
case SDL_Keycode.SDLK_LSHIFT: LeftShift = false; break;
default: break;
}
}
/// <summary>
/// Gets the keycode from the character/decimal set in the yaml.
/// </summary>
/// <param name="key">The key.</param>
private void GetKeycode(string key)
{
if (key.Length == 1)
{
this.Keycode = (SDL_Keycode)(Convert.ToChar(key));
}
else
{
SDL_Keycode _keycode;
Enum.TryParse(key, out _keycode);
if (_keycode == SDL_Keycode.UNKNOWN)
{
var newKey = key.Replace("\\b", "\b")
.Replace("\\r", "\r")
.Replace("\\t", "\t");
_keycode = (SDL_Keycode)(Convert.ToChar(newKey));
}
this.Keycode = _keycode;
}
}
private void SdlKeyDown(SDL_Keycode key)
{
switch (key)
{
case SDL_Keycode.SDLK_LSHIFT:
case SDL_Keycode.SDLK_RSHIFT:
_keyModifiers |= ImlacKeyModifiers.Shift;
break;
case SDL_Keycode.SDLK_LCTRL:
case SDL_Keycode.SDLK_RCTRL:
_keyModifiers |= ImlacKeyModifiers.Ctrl;
break;
case SDL_Keycode.SDLK_LALT:
case SDL_Keycode.SDLK_RALT:
_keyModifiers |= ImlacKeyModifiers.Rept;
break;
default:
UpdateDataSwitches(key, true /* key down */);
if (key == SDL_Keycode.SDLK_INSERT)
{
FullScreenToggle();
}
_keyLatchedLock.EnterWriteLock();
_keyLatched = true;
_latchedKeyCode = TranslateKeyCode(key);
_keyLatchedLock.ExitWriteLock();
break;
}
}
public KeyboardEventArgs(SDL_Keycode key, SDL_Keymod mod, KeyboardEvent state)
{
Key = key;
Mod = mod;
KeyboardEvent = state;
}
public override sealed SDL_Scancode SDL_GetScancodeFromKey(SDL_Keycode keycode) => INTERNAL_SDL_GetScancodeFromKey(keycode);
private static extern SDL_Scancode INTERNAL_SDL_GetScancodeFromKey(SDL_Keycode keycode);
public InputKeyboardEvent(KeyboardEvent eventtype, SDL_Keycode keycode, int key, SDL_Keymod modifiers) : base(modifiers)
{
EventType = eventtype;
KeyCode = keycode;
_keyDataExtra = key;
}
public static extern SDL_Scancode GetScancodeFromKey(SDL_Keycode keycode);
public static extern SDL_Scancode GetScancodeFromKey(SDL_Keycode keycode);
public static SDL_Scancode SDL_GetScancodeFromKey(SDL_Keycode keycode) => impl.SDL_GetScancodeFromKey(keycode);
public static void DebugKeys(SDL_Keycode button, int state)
{
if(state != 0)
{
if (MainInventoryManager != null)
{
switch (button)
{
case SDLK_RETURN:
MainInventoryManager.NextState = InventoryManager.InventoryState.Activate;
break;
case SDLK_UP:
MainInventoryManager.NextState = InventoryManager.InventoryState.Up;
break;
case SDLK_DOWN:
MainInventoryManager.NextState = InventoryManager.InventoryState.Down;
break;
case SDLK_LEFT:
MainInventoryManager.NextState = InventoryManager.InventoryState.RLeft;
break;
case SDLK_RIGHT:
MainInventoryManager.NextState = InventoryManager.InventoryState.RRight;
break;
}
}
}
}
/* Get a human-readable name for a key */
public static string SDL_GetKeyName(SDL_Keycode key)
{
return Marshal.PtrToStringAnsi(
INTERNAL_SDL_GetKeyName(key)
);
}
public Sdl2Key(SDL_Keycode symbol, int value)
{
this.Symbol = symbol;
this.Value = value;
}
public static void EvaluateEvent(SDL_Event e)
{
if (e.window.windowID == 0)
{
return;
}
IntPtr sdlwindow = SDL_GetWindowFromID(e.window.windowID);
Window w = Windows.Find(win => win != null && win.SDL_Window == sdlwindow);
if (w == null)
{
return;
}
int idx = Windows.IndexOf(w);
// After closing a window, there are still a few more events like losing focus;
// We can skip these as the window was already destroyed.
if (w == null)
{
return;
}
if (OldMouseX == -1)
{
OldMouseX = e.motion.x;
}
if (OldMouseY == -1)
{
OldMouseY = e.motion.y;
}
if (e.type == SDL_EventType.SDL_WINDOWEVENT)
{
switch (e.window.windowevent)
{
case SDL_WindowEventID.SDL_WINDOWEVENT_CLOSE:
BoolEventArgs ClosingArgs = new BoolEventArgs();
w.OnClosing(ClosingArgs);
if (!ClosingArgs.Value)
{
SDL_DestroyWindow(w.SDL_Window);
w.OnClosed(new BaseEventArgs());
w.Dispose();
Windows[idx] = null;
}
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_MOVED:
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_RESIZED:
int width1;
int height1;
SDL_GetWindowSize(w.SDL_Window, out width1, out height1);
w.OnSizeChanged(new BaseEventArgs());
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_SIZE_CHANGED:
int width2;
int height2;
SDL_GetWindowSize(w.SDL_Window, out width2, out height2);
w.OnSizeChanged(new BaseEventArgs());
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_GAINED:
w.Focus = true;
w.OnFocusGained(new BaseEventArgs());
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_LOST:
w.Focus = false;
w.OnFocusLost(new BaseEventArgs());
break;
}
}
if (Windows[idx] == null)
{
return; // Just disposed this window
}
if (w.Focus)
{
switch (e.type)
{
case SDL_EventType.SDL_MOUSEMOTION:
if (e.motion.x != OldMouseX || e.motion.y != OldMouseY)
{
LeftDown = (e.button.button & 1) == 1;
MiddleDown = (e.button.button & 2) == 2;
RightDown = (e.button.button & 4) == 4;
w.OnMouseMoving(new MouseEventArgs(e.motion.x, e.motion.y,
oldleftdown, LeftDown,
oldrightdown, RightDown,
oldmiddledown, MiddleDown));
}
OldMouseX = e.motion.x;
OldMouseY = e.motion.y;
break;
case SDL_EventType.SDL_MOUSEBUTTONDOWN:
if (e.button.button == 1)
{
LeftDown = true;
}
if (e.button.button == 2)
{
MiddleDown = true;
}
if (e.button.button == 3)
{
RightDown = true;
}
w.OnMouseDown(new MouseEventArgs(e.motion.x, e.motion.y,
oldleftdown, LeftDown,
oldrightdown, RightDown,
oldmiddledown, MiddleDown));
break;
case SDL_EventType.SDL_MOUSEBUTTONUP:
if (e.button.button == 1)
{
LeftDown = false;
}
if (e.button.button == 2)
{
MiddleDown = false;
}
if (e.button.button == 3)
{
RightDown = false;
}
w.OnMouseUp(new MouseEventArgs(e.motion.x, e.motion.y,
oldleftdown, LeftDown,
oldrightdown, RightDown,
oldmiddledown, MiddleDown));
break;
case SDL_EventType.SDL_MOUSEWHEEL:
w.OnMouseWheel(new MouseEventArgs(OldMouseX, OldMouseY,
oldleftdown, LeftDown,
oldrightdown, RightDown,
oldmiddledown, MiddleDown,
e.wheel.x, e.wheel.y));
break;
case SDL_EventType.SDL_KEYDOWN:
SDL_Keycode sym1 = e.key.keysym.sym;
Input.Register(sym1, true);
string txt = "";
bool backspace = false;
bool delete = false;
if (sym1 == SDL_Keycode.SDLK_RETURN)
{
txt = "\n";
}
if (sym1 == SDL_Keycode.SDLK_BACKSPACE)
{
backspace = true;
}
if (sym1 == SDL_Keycode.SDLK_DELETE)
{
delete = true;
}
if (txt.Length > 0 || backspace || delete)
{
w.OnTextInput(new TextEventArgs(txt, backspace, delete));
}
break;
case SDL_EventType.SDL_KEYUP:
SDL_Keycode sym2 = e.key.keysym.sym;
Input.Register(sym2, false);
break;
case SDL_EventType.SDL_TEXTINPUT:
byte[] bytes = new byte[32];
unsafe
{
byte *ptr = e.text.text;
byte *data = ptr;
int i = 0;
while (*data != 0)
{
bytes[i] = *data;
data++;
i++;
}
}
string text = "";
foreach (char c in Encoding.UTF8.GetChars(bytes))
{
text += c;
}
w.OnTextInput(new TextEventArgs(text.TrimEnd('\x00')));
break;
}
}
}
public static extern void SDL_GetScancodeFromKey(SDL_Keycode key);
public static bool KeyState(SDL_Keycode key)
{
return(_downKeys.Contains(key));
}
private static extern IntPtr INTERNAL_SDL_GetKeyName(SDL_Keycode key);
