using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework.Input;
using System.Runtime.InteropServices;
using FSO.Common.Rendering.Framework.Model;
namespace FSO.Common.Rendering.Framework.IO
{
/// <summary>
/// Manages input for the game.
/// </summary>
public class InputManager
{
private IFocusableUI LastFocus;
public bool RequireWindowFocus = false;
public void SetFocus(IFocusableUI ui)
{
/** No change **/
if (ui == LastFocus) { return; }
if (LastFocus != null)
{
LastFocus.OnFocusChanged(FocusEvent.FocusOut);
}
LastFocus = ui;
if (ui != null)
{
LastFocus.OnFocusChanged(FocusEvent.FocusIn);
}
}
public IFocusableUI GetFocus()
{
return LastFocus;
}
[DllImport("user32.dll")]
static extern int MapVirtualKey(uint uCode, uint uMapType);
/// <summary>
/// Utility to apply the result of pressing keys against a buffer
/// </summary>
/// <param name="buffer"></param>
/// <param name="keys"></param>
public KeyboardInputResult ApplyKeyboardInput(StringBuilder m_SBuilder, UpdateState state, int cursorIndex, int cursorEndIndex, bool allowInput)
{
if (!state.WindowFocused && RequireWindowFocus) { return null; }
var PressedKeys = state.KeyboardState.GetPressedKeys();
int charCount = 0;
if (state.FrameTextInput == null) charCount = 0;
else charCount = state.FrameTextInput.Count;
if (PressedKeys.Length + charCount == 0) { return null; }
//bit of a legacy thing going on here
//we support both "pressed keys" and the keyboard event system.
//todo: clean up a bit
var didChange = false;
var result = new KeyboardInputResult();
var m_CurrentKeyState = state.KeyboardState;
var m_OldKeyState = state.PreviousKeyboardState;
result.ShiftDown = PressedKeys.Contains(Keys.LeftShift) || PressedKeys.Contains(Keys.RightShift);
result.CapsDown = state.KeyboardState.CapsLock;
result.NumLockDown = state.KeyboardState.NumLock;
// Right alt aka AltGr is treated as Ctrl+Alt. It is used to type accented letters and other unusual characters so pressing that key cannot cause special actions.
result.CtrlDown = (PressedKeys.Contains(Keys.LeftControl) && !PressedKeys.Contains(Keys.RightAlt)) || PressedKeys.Contains(Keys.RightControl);
for (int j = 0; j < state.NewKeys.Count + charCount; j++)
{
var key = (j<state.NewKeys.Count)?state.NewKeys[j]:Keys.None;
bool processChar = true;
if (key != Keys.None)
{
processChar = false;
if (key == Keys.Back || key == Keys.Delete)
{
if (m_SBuilder.Length > 0)
{
/**
* Delete previous character or delete selection
*/
if (cursorEndIndex == -1 && result.CtrlDown)
{
/** Delete up until the previous whitespace char **/
int newEndIndex = cursorIndex;
if (newEndIndex == -1)
{
newEndIndex = m_SBuilder.Length;
cursorIndex = m_SBuilder.Length;
}
int dir = (key == Keys.Delete) ? 1 : -1;
int ws = (key == Keys.Delete) ? 0 : -1;
while (newEndIndex+ws >= 0 && newEndIndex+ws < m_SBuilder.Length)
{
if (Char.IsWhiteSpace(m_SBuilder[newEndIndex+ws]))
{
/** Keep the whitespace char **/
break;
}
newEndIndex += dir;
}
if (cursorIndex > newEndIndex)
{
cursorEndIndex = cursorIndex;
cursorIndex = newEndIndex;
}
else
cursorEndIndex = newEndIndex;
if (cursorEndIndex == cursorIndex)
cursorIndex = cursorEndIndex = -1;
}
if (cursorEndIndex == -1)
{
/** Previous character **/
var index = cursorIndex == -1 ? m_SBuilder.Length : cursorIndex;
if ((key == Keys.Back) && (index > 0))
{
var numToDelete = 1;
if (index > 1 && m_SBuilder[index - 1] == '\n' && m_SBuilder[index - 2] == '\r')
{
numToDelete = 2;
}
m_SBuilder.Remove(index - numToDelete, numToDelete);
result.NumDeletes += numToDelete;
if (cursorIndex != -1)
{
cursorIndex -= numToDelete;
}
}
else if ((key == Keys.Delete) && (index < m_SBuilder.Length))
{
/** Guys, delete removes the next character, not the last!! **/
var numToDelete = 1;
if ((index < m_SBuilder.Length - 1) && m_SBuilder[index] == '\r' && m_SBuilder[index + 1] == '\n')
{
numToDelete = 2;
}
m_SBuilder.Remove(index, numToDelete);
result.NumDeletes += numToDelete;
}
}
else
{
DeleteSelectedText(m_SBuilder, ref cursorIndex, ref cursorEndIndex, ref didChange, result);
}
result.SelectionChanged = true;
didChange = true;
}
}
else if (key == Keys.Enter)
{
if (allowInput)
{
/** Line break **/
if (cursorEndIndex != -1)
{
/** Delete selected text **/
DeleteSelectedText(m_SBuilder, ref cursorIndex, ref cursorEndIndex, ref didChange, result);
}
if (cursorIndex == -1)
{
m_SBuilder.Append("\n");
}
else
{
cursorIndex = Math.Min(m_SBuilder.Length, cursorIndex);
m_SBuilder.Insert(cursorIndex, "\n");
cursorIndex += 1;
}
result.NumInsertions += 1;
didChange = true;
result.EnterPressed = true;
}
}
else if (key == Keys.Tab)
{
result.TabPressed = true;
}
else if (result.CtrlDown)
{
switch (key)
{
case Keys.A:
/** Select all **/
cursorIndex = 0;
cursorEndIndex = m_SBuilder.Length;
result.SelectionChanged = true;
break;
case Keys.C:
case Keys.X:
/** Copy text to clipboard **/
if (cursorEndIndex > 0)
{
var selectionStart = Math.Max(0, cursorIndex);
var selectionEnd = cursorEndIndex;
GetSelectionRange(ref selectionStart, ref selectionEnd);
var str = m_SBuilder.ToString().Substring(selectionStart, selectionEnd - selectionStart);
ClipboardHandler.Default.Set(str);
if (key == Keys.X)
{
DeleteSelectedText(m_SBuilder, ref cursorIndex, ref cursorEndIndex, ref didChange, result);
}
}
break;
case Keys.V:
/** Paste text in **/
var clipboardText = ClipboardHandler.Default.Get();
if (clipboardText != null)
{
/** TODO: Cleanup the clipboard text to make sure its valid **/
/** If i have selection, delete it **/
if (cursorEndIndex != -1)
{
DeleteSelectedText(m_SBuilder, ref cursorIndex, ref cursorEndIndex, ref didChange, result);
}
/** Paste **/
if (cursorIndex == -1)
{
m_SBuilder.Append(clipboardText);
}
else
{
m_SBuilder.Insert(Math.Min(cursorIndex, m_SBuilder.Length), clipboardText);
cursorIndex += clipboardText.Length;
}
result.NumInsertions += clipboardText.Length;
didChange = true;
}
break;
}
} else {
result.UnhandledKeys.Add(key);
processChar = true;
}
}
if (processChar)
{
char value;
if (j >= state.NewKeys.Count) value = state.FrameTextInput[j - state.NewKeys.Count];
else if (state.FrameTextInput != null) continue;
else value = TranslateChar(key, result.ShiftDown, result.CapsDown, result.NumLockDown);
/** For now we dont support tabs in text **/
if (!char.IsControl(value) && value != '\0' && value != '\t' && value != '\b' && value != '\r')
{
if (allowInput)
{
if (cursorEndIndex != -1)
{
/** Delete selected text **/
DeleteSelectedText(m_SBuilder, ref cursorIndex, ref cursorEndIndex, ref didChange, result);
}
if (cursorIndex == -1)
{
m_SBuilder.Append(value);
}
else
{
m_SBuilder.Insert(cursorIndex, value);
cursorIndex++;
}
result.NumInsertions++;
didChange = true;
}
}
else
{
result.UnhandledKeys.Add(key);
}
}
}
result.SelectionStart = cursorIndex;
result.SelectionEnd = cursorEndIndex;
result.ContentChanged = didChange;
return result;
}
private void DeleteSelectedText(StringBuilder m_SBuilder, ref int cursorIndex, ref int cursorEndIndex, ref bool didChange, KeyboardInputResult result)
{
/** Remove selected text **/
var index = cursorIndex == -1 ? m_SBuilder.Length : cursorIndex;
var end = cursorEndIndex;
if (end < index)
{
var temp = index;
index = end;
end = temp;
}
m_SBuilder.Remove(index, end - index);
cursorIndex = index;
if (cursorIndex >= m_SBuilder.Length)
{
cursorIndex = -1;
}
cursorEndIndex = -1;
result.SelectionChanged = true;
didChange = true;
}
public void GetSelectionRange(ref int start, ref int end)
{
if (end < start)
{
var temp = start;
start = end;
end = temp;
}
}
public static char TranslateChar(Keys key, bool shift, bool capsLock, bool numLock)
{
switch (key)
{
case Keys.A: return TranslateAlphabetic('a', shift, capsLock);
case Keys.B: return TranslateAlphabetic('b', shift, capsLock);
case Keys.C: return TranslateAlphabetic('c', shift, capsLock);
case Keys.D: return TranslateAlphabetic('d', shift, capsLock);
case Keys.E: return TranslateAlphabetic('e', shift, capsLock);
case Keys.F: return TranslateAlphabetic('f', shift, capsLock);
case Keys.G: return TranslateAlphabetic('g', shift, capsLock);
case Keys.H: return TranslateAlphabetic('h', shift, capsLock);
case Keys.I: return TranslateAlphabetic('i', shift, capsLock);
case Keys.J: return TranslateAlphabetic('j', shift, capsLock);
case Keys.K: return TranslateAlphabetic('k', shift, capsLock);
case Keys.L: return TranslateAlphabetic('l', shift, capsLock);
case Keys.M: return TranslateAlphabetic('m', shift, capsLock);
case Keys.N: return TranslateAlphabetic('n', shift, capsLock);
case Keys.O: return TranslateAlphabetic('o', shift, capsLock);
case Keys.P: return TranslateAlphabetic('p', shift, capsLock);
case Keys.Q: return TranslateAlphabetic('q', shift, capsLock);
case Keys.R: return TranslateAlphabetic('r', shift, capsLock);
case Keys.S: return TranslateAlphabetic('s', shift, capsLock);
case Keys.T: return TranslateAlphabetic('t', shift, capsLock);
case Keys.U: return TranslateAlphabetic('u', shift, capsLock);
case Keys.V: return TranslateAlphabetic('v', shift, capsLock);
case Keys.W: return TranslateAlphabetic('w', shift, capsLock);
case Keys.X: return TranslateAlphabetic('x', shift, capsLock);
case Keys.Y: return TranslateAlphabetic('y', shift, capsLock);
case Keys.Z: return TranslateAlphabetic('z', shift, capsLock);
case Keys.D0: return (shift) ? ')' : '0';
case Keys.D1: return (shift) ? '!' : '1';
case Keys.D2: return (shift) ? '@' : '2';
case Keys.D3: return (shift) ? '#' : '3';
case Keys.D4: return (shift) ? '$' : '4';
case Keys.D5: return (shift) ? '%' : '5';
case Keys.D6: return (shift) ? '^' : '6';
case Keys.D7: return (shift) ? '&' : '7';
case Keys.D8: return (shift) ? '*' : '8';
case Keys.D9: return (shift) ? '(' : '9';
case Keys.Add: return '+';
case Keys.Divide: return '/';
case Keys.Multiply: return '*';
case Keys.Subtract: return '-';
case Keys.Space: return ' ';
case Keys.Tab: return '\t';
case Keys.Decimal: if (numLock && !shift) return '.'; break;
case Keys.NumPad0: if (numLock && !shift) return '0'; break;
case Keys.NumPad1: if (numLock && !shift) return '1'; break;
case Keys.NumPad2: if (numLock && !shift) return '2'; break;
case Keys.NumPad3: if (numLock && !shift) return '3'; break;
case Keys.NumPad4: if (numLock && !shift) return '4'; break;
case Keys.NumPad5: if (numLock && !shift) return '5'; break;
case Keys.NumPad6: if (numLock && !shift) return '6'; break;
case Keys.NumPad7: if (numLock && !shift) return '7'; break;
case Keys.NumPad8: if (numLock && !shift) return '8'; break;
case Keys.NumPad9: if (numLock && !shift) return '9'; break;
case Keys.OemBackslash: return shift ? '|' : '\\';
case Keys.OemCloseBrackets: return shift ? '}' : ']';
case Keys.OemComma: return shift ? '<' : ',';
case Keys.OemMinus: return shift ? '_' : '-';
case Keys.OemOpenBrackets: return shift ? '{' : '[';
case Keys.OemPeriod: return shift ? '>' : '.';
case Keys.OemPipe: return shift ? '|' : '\\';
case Keys.OemPlus: return shift ? '+' : '=';
case Keys.OemQuestion: return shift ? '?' : '/';
case Keys.OemQuotes: return shift ? '"' : '\'';
case Keys.OemSemicolon: return shift ? ':' : ';';
case Keys.OemTilde: return shift ? '~' : '`';
}
return (char)0;
}
public static char TranslateAlphabetic(char baseChar, bool shift, bool capsLock)
{
return (capsLock ^ shift) ? char.ToUpper(baseChar) : baseChar;
}
public void HandleMouseEvents(UpdateState state)
{
foreach (var mouse in state.MouseStates) {
var mouseBtnDown = mouse.MouseState.LeftButton == Microsoft.Xna.Framework.Input.ButtonState.Pressed;
var mouseDif = mouseBtnDown != mouse.LastMouseDownState;
if (mouse.NewMultiMouse) mouse.NewMultiMouse = false;
else
mouse.LastMouseDownState = mouseBtnDown;
state.MouseState = mouse.MouseState; //make sure each event uses the mouse state for this mouse.
state.CurrentMouseID = mouse.ID;
//if anyone accesses vanilla mouse state during the update loop, it will be the last mouse that was present.
var topMost =
state.MouseEvents.Where(x => x.Item1 == mouse.ID).OrderByDescending(x => x.Item2.Element.Depth).FirstOrDefault();
if (topMost != null && !mouse.Dead)
{
/** different element? **/
if (mouse.LastMouseOver != topMost.Item2)
{
if (mouse.LastMouseOver != null)
{
mouse.LastMouseOver.Callback(UIMouseEventType.MouseOut, state);
}
topMost.Item2.Callback(UIMouseEventType.MouseOver, state);
mouse.LastMouseOver = topMost.Item2;
}
}
else
{
if (mouse.LastMouseOver != null)
{
mouse.LastMouseOver.Callback(UIMouseEventType.MouseOut, state);
mouse.LastMouseOver = null;
}
}
if (mouseDif)
{
if (mouseBtnDown)
{
if (mouse.LastMouseDown != null)
{
/** We already have mouse down on an object **/
return;
}
if (mouse.LastMouseOver != null)
{
mouse.LastMouseDown = mouse.LastMouseOver;
mouse.LastMouseDown.Callback(UIMouseEventType.MouseDown, state);
}
}
else
{
if (mouse.LastMouseDown != null)
{
mouse.LastMouseDown.Callback(UIMouseEventType.MouseUp, state);
mouse.LastMouseDown = null;
}
}
}
}
}
}
public class KeyboardInputResult
{
public List<Keys> UnhandledKeys = new List<Keys>();
public bool ContentChanged;
public bool ShiftDown;
public bool CapsDown;
public bool NumLockDown;
public bool CtrlDown;
public bool EnterPressed;
public bool TabPressed;
public int NumDeletes;
public int NumInsertions;
public int SelectionStart;
public int SelectionEnd;
public bool SelectionChanged;
}
}