using System; using System.Linq; using System.Reflection; using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Input; using MLEM.Input; namespace MLEM.Misc { /// /// A text input wrapper is a wrapper around MonoGame's built-in text input event. /// Since said text input event does not exist on non-Desktop devices, we want to wrap it in a wrapper that is platform-independent for MLEM. /// See subclasses of this wrapper or for more info. /// public abstract class TextInputWrapper { private static TextInputWrapper current; /// /// The current text input wrapper. /// Set this value before starting your game if you want to use text input wrapping. /// /// public static TextInputWrapper Current { get { if (current == null) throw new InvalidOperationException("The TextInputWrapper was not initialized. For more information, see https://mlem.ellpeck.de/articles/ui.html#text-input"); return current; } set => current = value; } /// /// Determines if this text input wrapper requires an on-screen keyboard. /// /// If this text input wrapper requires an on-screen keyboard public abstract bool RequiresOnScreenKeyboard(); /// /// Adds a text input listener to this text input wrapper. /// The supplied listener will be called whenever a character is input. /// /// The game's window /// The callback that should be called whenever a character is pressed public abstract void AddListener(GameWindow window, TextInputCallback callback); /// /// A delegate method that can be used for /// /// The object that sent the event. The used in most cases. /// The key that was pressed /// The character that corresponds to that key public delegate void TextInputCallback(object sender, Keys key, char character); /// /// A text input wrapper for DesktopGL devices. /// This wrapper uses the built-in MonoGame TextInput event, which makes this listener work with any keyboard localization natively. /// /// /// This listener is initialized as follows: /// /// new TextInputWrapper.DesktopGl{TextInputEventArgs}((w, c) => w.TextInput += c); /// /// /// public class DesktopGl : TextInputWrapper { private MemberInfo key; private MemberInfo character; private readonly Action> addListener; /// /// Creates a new DesktopGL-based text input wrapper /// /// The function that is used to add a text input listener public DesktopGl(Action> addListener) { this.addListener = addListener; } /// public override bool RequiresOnScreenKeyboard() { return false; } /// public override void AddListener(GameWindow window, TextInputCallback callback) { this.addListener(window, (sender, args) => { // the old versions of DesktopGL use a property here, while the // core version uses a field. So much for "no breaking changes" if (this.key == null) this.key = GetMember(args, "Key"); if (this.character == null) this.character = GetMember(args, "Character"); callback.Invoke(sender, GetValue(this.key, args), GetValue(this.character, args)); }); } private static MemberInfo GetMember(object args, string name) { var ret = args.GetType().GetProperty(name); if (ret != null) return ret; return args.GetType().GetField(name); } private static U GetValue(MemberInfo member, object args) { switch (member) { case PropertyInfo p: return (U) p.GetValue(args); case FieldInfo f: return (U) f.GetValue(args); } throw new ArgumentException(); } } /// /// A text input wrapper for mobile platforms as well as consoles. /// This text input wrapper performs no actions itself, as it signals that an on-screen keyboard is required. /// public class Mobile : TextInputWrapper { /// public override bool RequiresOnScreenKeyboard() { return true; } /// public override void AddListener(GameWindow window, TextInputCallback callback) { } } /// /// A text input wrapper that does nothing. /// This can be used if no text input is required for the game. /// public class None : TextInputWrapper { /// public override bool RequiresOnScreenKeyboard() { return false; } /// public override void AddListener(GameWindow window, TextInputCallback callback) { } } /// /// A primitive text input wrapper that is locked to the American keyboard localization. /// Only use this text input wrapper if is unavailable for some reason. /// /// Note that, when using this text input wrapper, its method has to be called periodically. /// public class Primitive : TextInputWrapper { private TextInputCallback callback; /// /// Updates this text input wrapper by querying pressed keys and sending corresponding input events. /// /// The input handler to use for text input querying public void Update(InputHandler handler) { var pressed = handler.KeyboardState.GetPressedKeys().Except(handler.LastKeyboardState.GetPressedKeys()); var shift = handler.IsModifierKeyDown(ModifierKey.Shift); foreach (var key in pressed) { var c = GetChar(key, shift); if (c.HasValue) this.callback?.Invoke(this, key, c.Value); } } /// public override bool RequiresOnScreenKeyboard() { return false; } /// public override void AddListener(GameWindow window, TextInputCallback callback) { this.callback += callback; } private static char? GetChar(Keys key, bool shift) { if (key == Keys.A) return shift ? 'A' : 'a'; if (key == Keys.B) return shift ? 'B' : 'b'; if (key == Keys.C) return shift ? 'C' : 'c'; if (key == Keys.D) return shift ? 'D' : 'd'; if (key == Keys.E) return shift ? 'E' : 'e'; if (key == Keys.F) return shift ? 'F' : 'f'; if (key == Keys.G) return shift ? 'G' : 'g'; if (key == Keys.H) return shift ? 'H' : 'h'; if (key == Keys.I) return shift ? 'I' : 'i'; if (key == Keys.J) return shift ? 'J' : 'j'; if (key == Keys.K) return shift ? 'K' : 'k'; if (key == Keys.L) return shift ? 'L' : 'l'; if (key == Keys.M) return shift ? 'M' : 'm'; if (key == Keys.N) return shift ? 'N' : 'n'; if (key == Keys.O) return shift ? 'O' : 'o'; if (key == Keys.P) return shift ? 'P' : 'p'; if (key == Keys.Q) return shift ? 'Q' : 'q'; if (key == Keys.R) return shift ? 'R' : 'r'; if (key == Keys.S) return shift ? 'S' : 's'; if (key == Keys.T) return shift ? 'T' : 't'; if (key == Keys.U) return shift ? 'U' : 'u'; if (key == Keys.V) return shift ? 'V' : 'v'; if (key == Keys.W) return shift ? 'W' : 'w'; if (key == Keys.X) return shift ? 'X' : 'x'; if (key == Keys.Y) return shift ? 'Y' : 'y'; if (key == Keys.Z) return shift ? 'Z' : 'z'; if (key == Keys.D0 && !shift || key == Keys.NumPad0) return '0'; if (key == Keys.D1 && !shift || key == Keys.NumPad1) return '1'; if (key == Keys.D2 && !shift || key == Keys.NumPad2) return '2'; if (key == Keys.D3 && !shift || key == Keys.NumPad3) return '3'; if (key == Keys.D4 && !shift || key == Keys.NumPad4) return '4'; if (key == Keys.D5 && !shift || key == Keys.NumPad5) return '5'; if (key == Keys.D6 && !shift || key == Keys.NumPad6) return '6'; if (key == Keys.D7 && !shift || key == Keys.NumPad7) return '7'; if (key == Keys.D8 && !shift || key == Keys.NumPad8) return '8'; if (key == Keys.D9 && !shift || key == Keys.NumPad9) return '9'; if (key == Keys.D0 && shift) return ')'; if (key == Keys.D1 && shift) return '!'; if (key == Keys.D2 && shift) return '@'; if (key == Keys.D3 && shift) return '#'; if (key == Keys.D4 && shift) return '$'; if (key == Keys.D5 && shift) return '%'; if (key == Keys.D6 && shift) return '^'; if (key == Keys.D7 && shift) return '&'; if (key == Keys.D8 && shift) return '*'; if (key == Keys.D9 && shift) return '('; if (key == Keys.Space) return ' '; if (key == Keys.Tab) return '\t'; if (key == Keys.Add) return '+'; if (key == Keys.Decimal) return '.'; if (key == Keys.Divide) return '/'; if (key == Keys.Multiply) return '*'; if (key == Keys.OemBackslash) return '\\'; if (key == Keys.OemComma && !shift) return ','; if (key == Keys.OemComma && shift) return '<'; if (key == Keys.OemOpenBrackets && !shift) return '['; if (key == Keys.OemOpenBrackets && shift) return '{'; if (key == Keys.OemCloseBrackets && !shift) return ']'; if (key == Keys.OemCloseBrackets && shift) return '}'; if (key == Keys.OemPeriod && !shift) return '.'; if (key == Keys.OemPeriod && shift) return '>'; if (key == Keys.OemPipe && !shift) return '\\'; if (key == Keys.OemPipe && shift) return '|'; if (key == Keys.OemPlus && !shift) return '='; if (key == Keys.OemPlus && shift) return '+'; if (key == Keys.OemMinus && !shift) return '-'; if (key == Keys.OemMinus && shift) return '_'; if (key == Keys.OemQuestion && !shift) return '/'; if (key == Keys.OemQuestion && shift) return '?'; if (key == Keys.OemQuotes && !shift) return '\''; if (key == Keys.OemQuotes && shift) return '"'; if (key == Keys.OemSemicolon && !shift) return ';'; if (key == Keys.OemSemicolon && shift) return ':'; if (key == Keys.OemTilde && !shift) return '`'; if (key == Keys.OemTilde && shift) return '~'; if (key == Keys.Subtract) return '-'; return null; } } } }