diff --git a/Source/Examples/Main.cs b/Source/Examples/Main.cs index 213948be..cb940537 100644 --- a/Source/Examples/Main.cs +++ b/Source/Examples/Main.cs @@ -52,6 +52,7 @@ namespace Examples // The ExampleBrowser works pretty poorly on some platforms, so you may want to start examples directly. // for example: Examples.Tutorial.T12_GLSL_Parallax.Main (); // Examples.Tutorial.T10_GLSL_Cube.Main (); + Examples.Tests.BasicMouseInput.Main (); using (Form browser = new ExampleBrowser()) { diff --git a/Source/Examples/OpenTK/Test/BasicMouseInput.cs b/Source/Examples/OpenTK/Test/BasicMouseInput.cs index c106782e..a66d8268 100644 --- a/Source/Examples/OpenTK/Test/BasicMouseInput.cs +++ b/Source/Examples/OpenTK/Test/BasicMouseInput.cs @@ -25,7 +25,7 @@ namespace Examples.Tests { public BasicMouseInput() - : base(800, 600, GraphicsMode.Default) + : base(800, 600) { } protected override void OnLoad(EventArgs e) @@ -42,6 +42,8 @@ namespace Examples.Tests protected override void OnUpdateFrame(FrameEventArgs e) { + base.OnUpdateFrame(e); + // Here's the big test! if(OpenTK.Input.Mouse.GetState()[MouseButton.Left]){ Console.WriteLine("The left mouse button is down!"); @@ -66,7 +68,7 @@ namespace Examples.Tests protected override void OnRenderFrame(FrameEventArgs e) { - GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); + GL.Clear(ClearBufferMask.ColorBufferBit); SwapBuffers(); } @@ -78,7 +80,8 @@ namespace Examples.Tests // Get the title and category of this example using reflection. ExampleAttribute info = ((ExampleAttribute)example.GetType().GetCustomAttributes(false)[0]); example.Title = String.Format("OpenTK | {0} {1}: {2}", info.Category, info.Difficulty, info.Title); - example.Run(30.0, 0.0); + + example.Run(30.0); } } diff --git a/Source/OpenTK/Input/KeyboardDevice.cs b/Source/OpenTK/Input/KeyboardDevice.cs index b1a14b9c..d21ca5a7 100644 --- a/Source/OpenTK/Input/KeyboardDevice.cs +++ b/Source/OpenTK/Input/KeyboardDevice.cs @@ -22,6 +22,7 @@ namespace OpenTK.Input { //private IKeyboard keyboard; private bool[] keys = new bool[Enum.GetValues(typeof(Key)).Length]; + private bool[] scancodes = new bool[256]; private string description; private int numKeys, numFKeys, numLeds; private IntPtr devID; @@ -44,24 +45,16 @@ namespace OpenTK.Input public bool this[Key key] { get { return keys[(int)key]; } - internal set - { - if (keys[(int)key] != value || KeyRepeat) - { - keys[(int)key] = value; + } - if (value && KeyDown != null) - { - args.Key = key; - KeyDown(this, args); - } - else if (!value && KeyUp != null) - { - args.Key = key; - KeyUp(this, args); - } - } - } + /// + /// Gets a value indicating the status of the specified Key. + /// + /// The scancode to check. + /// True if the scancode is pressed, false otherwise. + public bool this[uint scancode] + { + get { return scancodes[scancode]; } } /// @@ -197,12 +190,34 @@ namespace OpenTK.Input internal void ClearKeys() { for (int i = 0; i < keys.Length; i++) - if (this[(Key)i]) // Make sure KeyUp events are *not* raised for keys that are up, even if key repeat is on. - this[(Key)i] = false; + keys[i] = false; + for (uint i = 0; i < scancodes.Length; i++) + scancodes[i] = false; } #endregion + internal void SetKey(Key key, uint scancode, bool state) + { + if (keys[(int)key] != state || KeyRepeat) + { + keys[(int)key] = scancodes[scancode] = state; + + if (state && KeyDown != null) + { + args.Key = key; + args.ScanCode = scancode; + KeyDown(this, args); + } + else if (!state && KeyUp != null) + { + args.Key = key; + args.ScanCode = scancode; + KeyUp(this, args); + } + } + } + #endregion } } \ No newline at end of file diff --git a/Source/OpenTK/Input/KeyboardKeyEventArgs.cs b/Source/OpenTK/Input/KeyboardKeyEventArgs.cs index ac3ce8af..f607090c 100644 --- a/Source/OpenTK/Input/KeyboardKeyEventArgs.cs +++ b/Source/OpenTK/Input/KeyboardKeyEventArgs.cs @@ -1,83 +1,95 @@ -#region License -// -// The Open Toolkit Library License -// -// Copyright (c) 2006 - 2009 the Open Toolkit library. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights to -// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -// the Software, and to permit persons to whom the Software is furnished to do -// so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES -// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT -// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR -// OTHER DEALINGS IN THE SOFTWARE. -// -#endregion - -using System; -using System.Collections.Generic; -using System.Text; - -namespace OpenTK.Input -{ - /// - /// Defines the event data for events. - /// - /// - /// - /// Do not cache instances of this type outside their event handler. - /// If necessary, you can clone a KeyboardEventArgs instance using the - /// constructor. - /// - /// - public class KeyboardKeyEventArgs : EventArgs - { - #region Fields - - Key key; - - #endregion - - #region Constructors - - /// - /// Constructs a new KeyboardEventArgs instance. - /// - public KeyboardKeyEventArgs() { } - - /// - /// Constructs a new KeyboardEventArgs instance. - /// - /// An existing KeyboardEventArgs instance to clone. - public KeyboardKeyEventArgs(KeyboardKeyEventArgs args) - { - Key = args.Key; - } - - #endregion - - #region Public Members - - /// - /// Gets the that generated this event. - /// - public Key Key - { - get { return key; } - internal set { key = value; } - } - - #endregion - } -} +#region License +// +// The Open Toolkit Library License +// +// Copyright (c) 2006 - 2009 the Open Toolkit library. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do +// so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +#endregion + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.Input +{ + /// + /// Defines the event data for events. + /// + /// + /// + /// Do not cache instances of this type outside their event handler. + /// If necessary, you can clone a KeyboardEventArgs instance using the + /// constructor. + /// + /// + public class KeyboardKeyEventArgs : EventArgs + { + #region Fields + + Key key; + uint scancode; + + #endregion + + #region Constructors + + /// + /// Constructs a new KeyboardEventArgs instance. + /// + public KeyboardKeyEventArgs() { } + + /// + /// Constructs a new KeyboardEventArgs instance. + /// + /// An existing KeyboardEventArgs instance to clone. + public KeyboardKeyEventArgs(KeyboardKeyEventArgs args) + { + Key = args.Key; + ScanCode = args.ScanCode; + } + + #endregion + + #region Public Members + + /// + /// Gets the that generated this event. + /// + public Key Key + { + get { return key; } + internal set { key = value; } + } + + /// + /// Gets the scancode which generated this event. + /// + public uint ScanCode + { + get { return scancode; } + internal set { scancode = value; } + } + + + #endregion + } +} diff --git a/Source/OpenTK/Input/KeyboardState.cs b/Source/OpenTK/Input/KeyboardState.cs index d37c60da..839fa2cd 100644 --- a/Source/OpenTK/Input/KeyboardState.cs +++ b/Source/OpenTK/Input/KeyboardState.cs @@ -43,6 +43,7 @@ namespace OpenTK.Input const int NumInts = ((int)Key.LastKey + IntSize - 1) / IntSize; // The following line triggers bogus CS0214 in gmcs 2.0.1, sigh... unsafe fixed int Keys[NumInts]; + unsafe fixed int Codes[256]; bool is_connected; #endregion @@ -58,13 +59,17 @@ namespace OpenTK.Input public bool this[Key key] { get { return IsKeyDown(key); } - internal set - { - if (value) - EnableBit((int)key); - else - DisableBit((int)key); - } + } + + /// + /// Gets a indicating whether the specified + /// is pressed. + /// + /// The to check. + /// True if key is pressed; false otherwise. + public bool this[short code] + { + get { return IsKeyDown(code); } } /// @@ -76,6 +81,15 @@ namespace OpenTK.Input return ReadBit((int)key); } + /// + /// Gets a indicating whether this scan code is down. + /// + /// The scan code to check. + public bool IsKeyDown(short code) + { + return ReadBit(code,true); + } + /// /// Gets a indicating whether this key is up. /// @@ -85,6 +99,15 @@ namespace OpenTK.Input return !ReadBit((int)key); } + /// + /// Gets a indicating whether this scan code is down. + /// + /// The scan code to check. + public bool IsKeyUp(short code) + { + return !ReadBit(code,true); + } + /// /// Gets a indicating whether this keyboard /// is connected. @@ -187,48 +210,62 @@ namespace OpenTK.Input #region Internal Members - internal bool ReadBit(int offset) + internal void SetKeyState(Key key, byte code, bool down) { - ValidateOffset(offset); - - int int_offset = offset / 32; - int bit_offset = offset % 32; - unsafe + if (down) { - fixed (int* k = Keys) - { - return (*(k + int_offset) & (1 << bit_offset)) != 0u; - } + EnableBit((int)key); + EnableBit(code,true); + } + else + { + DisableBit((int)key); + DisableBit(code, true); } } - internal void EnableBit(int offset) + internal bool ReadBit(int offset, bool ScanCode = false) { - ValidateOffset(offset); + ValidateOffset(offset, ScanCode); int int_offset = offset / 32; int bit_offset = offset % 32; unsafe { - fixed (int* k = Keys) - { - *(k + int_offset) |= 1 << bit_offset; - } + if (ScanCode) + fixed (int* c = Codes) { return (*(c + int_offset) & (1 << bit_offset)) != 0u; } + else + fixed (int* k = Keys) { return (*(k + int_offset) & (1 << bit_offset)) != 0u; } } } - internal void DisableBit(int offset) + internal void EnableBit(int offset, bool ScanCode = false) { - ValidateOffset(offset); + ValidateOffset(offset, ScanCode); int int_offset = offset / 32; int bit_offset = offset % 32; unsafe { - fixed (int* k = Keys) - { - *(k + int_offset) &= ~(1 << bit_offset); - } + if (ScanCode) + fixed (int* c = Codes) { *(c + int_offset) |= 1 << bit_offset; } + else + fixed (int* k = Keys) { *(k + int_offset) |= 1 << bit_offset; } + } + } + + internal void DisableBit(int offset, bool ScanCode = false) + { + ValidateOffset(offset, ScanCode); + + int int_offset = offset / 32; + int bit_offset = offset % 32; + unsafe + { + if (ScanCode) + fixed (int* c = Codes) { *(c + int_offset) &= ~(1 << bit_offset); } + else + fixed (int* k = Keys) { *(k + int_offset) &= ~(1 << bit_offset); } } } @@ -242,6 +279,12 @@ namespace OpenTK.Input for (int i = 0; i < NumInts; i++) *(k1 + i) |= *(k2 + i); } + int* c2 = other.Codes; + fixed (int* c1 = Codes) + { + for (int i = 0; i < short.MaxValue; i++) + *(c1 + i) |= *(c2 + i); + } } IsConnected |= other.IsConnected; } @@ -250,9 +293,9 @@ namespace OpenTK.Input #region Private Members - static void ValidateOffset(int offset) + static void ValidateOffset(int offset, bool ScanCode) { - if (offset < 0 || offset >= NumInts * IntSize) + if (offset < 0 || offset >= (ScanCode ? 256 : NumInts * IntSize)) throw new ArgumentOutOfRangeException("offset"); } diff --git a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs index 01696252..742847f9 100644 --- a/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs +++ b/Source/OpenTK/Platform/MacOS/CarbonGLNative.cs @@ -368,6 +368,7 @@ namespace OpenTK.Platform.MacOS break; } + OpenTK.Input.Key key; switch (evt.KeyboardEventKind) { case KeyboardEventKind.RawKeyRepeat: @@ -376,25 +377,15 @@ namespace OpenTK.Platform.MacOS break; case KeyboardEventKind.RawKeyDown: - { - OpenTK.Input.Key key; - if (Keymap.TryGetValue(code, out key)) - { - InputDriver.Keyboard[0][key] = true; - OnKeyPress(mKeyPressArgs); - } + Keymap.TryGetValue(code, out key); + InputDriver.Keyboard[0].SetKey(key, (uint)code, true); + OnKeyPress(mKeyPressArgs); return OSStatus.NoError; - } case KeyboardEventKind.RawKeyUp: - { - OpenTK.Input.Key key; - if (Keymap.TryGetValue(code, out key)) - { - InputDriver.Keyboard[0][key] = false; - } + Keymap.TryGetValue(code, out key); + InputDriver.Keyboard[0].SetKey(key, (uint)code, false); return OSStatus.NoError; - } case KeyboardEventKind.RawKeyModifiersChanged: ProcessModifierKey(inEvent); @@ -614,21 +605,21 @@ namespace OpenTK.Platform.MacOS Debug.Print("Modifiers Changed: {0}", modifiers); Input.KeyboardDevice keyboard = InputDriver.Keyboard[0]; - + if (keyboard[OpenTK.Input.Key.AltLeft] ^ option) - keyboard[OpenTK.Input.Key.AltLeft] = option; + keyboard.SetKey(OpenTK.Input.Key.AltLeft, (uint)MacOSKeyModifiers.Option, option); if (keyboard[OpenTK.Input.Key.ShiftLeft] ^ shift) - keyboard[OpenTK.Input.Key.ShiftLeft] = shift; + keyboard.SetKey(OpenTK.Input.Key.ShiftLeft, (uint)MacOSKeyModifiers.Shift, shift); if (keyboard[OpenTK.Input.Key.WinLeft] ^ command) - keyboard[OpenTK.Input.Key.WinLeft] = command; + keyboard.SetKey(OpenTK.Input.Key.WinLeft, (uint)MacOSKeyModifiers.Command, command); if (keyboard[OpenTK.Input.Key.ControlLeft] ^ control) - keyboard[OpenTK.Input.Key.ControlLeft] = control; + keyboard.SetKey(OpenTK.Input.Key.ControlLeft, (uint)MacOSKeyModifiers.Control, control); if (keyboard[OpenTK.Input.Key.CapsLock] ^ caps) - keyboard[OpenTK.Input.Key.CapsLock] = caps; + keyboard.SetKey(OpenTK.Input.Key.CapsLock, (uint)MacOSKeyModifiers.CapsLock, caps); } diff --git a/Source/OpenTK/Platform/MacOS/HIDInput.cs b/Source/OpenTK/Platform/MacOS/HIDInput.cs index daa88f3f..c040ff6d 100755 --- a/Source/OpenTK/Platform/MacOS/HIDInput.cs +++ b/Source/OpenTK/Platform/MacOS/HIDInput.cs @@ -263,14 +263,12 @@ namespace OpenTK.Platform.MacOS { case HIDPage.GenericDesktop: case HIDPage.KeyboardOrKeypad: - int raw = (int) usage; - if (raw >= RawKeyMap.Length) + if (usage >= RawKeyMap.Length) { - Debug.Print("[Warning] Key {0} not mapped.", raw); + Debug.Print("[Warning] Key {0} not mapped.", usage); return state; } - Key key = RawKeyMap[raw]; - state[key] = v_int != 0; + state.SetKeyState(RawKeyMap[usage], (byte)usage, v_int != 0); break; } diff --git a/Source/OpenTK/Platform/Windows/WMInput.cs b/Source/OpenTK/Platform/Windows/WMInput.cs index f0fd2956..084f20fb 100644 --- a/Source/OpenTK/Platform/Windows/WMInput.cs +++ b/Source/OpenTK/Platform/Windows/WMInput.cs @@ -70,14 +70,12 @@ namespace OpenTK.Platform.Windows void UpdateKeyboard() { - for (int i = 0; i < 256; i++) + for (byte i = 0; i < byte.MaxValue; i++) { - VirtualKeys key = (VirtualKeys)i; - bool pressed = (Functions.GetAsyncKeyState(key) >> 8) != 0; - if (KeyMap.ContainsKey(key)) - { - keyboard[KeyMap[key]] = pressed; - } + bool pressed = (Functions.GetAsyncKeyState((VirtualKeys)i) >> 8) != 0; + Key key; + KeyMap.TryGetValue((VirtualKeys)i,out key); + keyboard.SetKeyState(key, i, pressed); } } diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs index 261cfacf..18cbd3dd 100644 --- a/Source/OpenTK/Platform/Windows/WinGLNative.cs +++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs @@ -89,7 +89,13 @@ namespace OpenTK.Platform.Windows IList keyboards = new List(1); IList mice = new List(1); const long ExtendedBit = 1 << 24; // Used to distinguish left and right control, alt and enter keys. - static readonly uint ShiftRightScanCode = Functions.MapVirtualKey(VirtualKeys.RSHIFT, 0); // Used to distinguish left and right shift keys. + + public static readonly uint ShiftLeftScanCode = Functions.MapVirtualKey(VirtualKeys.LSHIFT, 0); + public static readonly uint ShiftRightScanCode = Functions.MapVirtualKey(VirtualKeys.RSHIFT, 0); + public static readonly uint ControlLeftScanCode = Functions.MapVirtualKey(VirtualKeys.LCONTROL, 0); + public static readonly uint ControlRightScanCode = Functions.MapVirtualKey(VirtualKeys.RCONTROL, 0); + public static readonly uint AltLeftScanCode = Functions.MapVirtualKey(VirtualKeys.LMENU, 0); + public static readonly uint AltRightScanCode = Functions.MapVirtualKey(VirtualKeys.RMENU, 0); KeyPressEventArgs key_press = new KeyPressEventArgs((char)0); @@ -369,6 +375,8 @@ namespace OpenTK.Platform.Windows // In this case, both keys will be reported as pressed. bool extended = (lParam.ToInt64() & ExtendedBit) != 0; + uint scancode = (uint)((lParam.ToInt64() >> 16) & 0xFF); + Key key = Key.Unknown; switch ((VirtualKeys)wParam) { case VirtualKeys.SHIFT: @@ -382,55 +390,50 @@ namespace OpenTK.Platform.Windows // Otherwise, the state of one key might be stuck to pressed. if (ShiftRightScanCode != 0 && pressed) { - unchecked - { - if (((lParam.ToInt64() >> 16) & 0xFF) == ShiftRightScanCode) - keyboard[Input.Key.ShiftRight] = pressed; - else - keyboard[Input.Key.ShiftLeft] = pressed; - } + if (scancode == ShiftRightScanCode) + key = Input.Key.ShiftRight; + else + key = Input.Key.ShiftLeft; } else { // Windows 9x and NT4.0 or key release event. - keyboard[Input.Key.ShiftLeft] = keyboard[Input.Key.ShiftRight] = pressed; + keyboard.SetKey(Input.Key.ShiftLeft, ShiftLeftScanCode, pressed); + keyboard.SetKey(Input.Key.ShiftRight, ShiftRightScanCode, pressed); } - return IntPtr.Zero; + break; case VirtualKeys.CONTROL: if (extended) - keyboard[Input.Key.ControlRight] = pressed; + key = Input.Key.ControlRight; else - keyboard[Input.Key.ControlLeft] = pressed; - return IntPtr.Zero; + key = Input.Key.ControlLeft; + break; case VirtualKeys.MENU: if (extended) - keyboard[Input.Key.AltRight] = pressed; + key = Input.Key.AltRight; else - keyboard[Input.Key.AltLeft] = pressed; - return IntPtr.Zero; + key = Input.Key.AltLeft; + break; case VirtualKeys.RETURN: if (extended) - keyboard[Key.KeypadEnter] = pressed; + key = Key.KeypadEnter; else - keyboard[Key.Enter] = pressed; - return IntPtr.Zero; + key = Key.Enter; + break; default: if (!KeyMap.ContainsKey((VirtualKeys)wParam)) - { Debug.Print("Virtual key {0} ({1}) not mapped.", (VirtualKeys)wParam, (long)lParam); - break; - } else - { - keyboard[KeyMap[(VirtualKeys)wParam]] = pressed; - } - return IntPtr.Zero; + key = KeyMap[(VirtualKeys)wParam]; + break; } - break; + + keyboard.SetKey(key, scancode, pressed); + return IntPtr.Zero; case WindowMessage.SYSCHAR: return IntPtr.Zero; diff --git a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs index 32faae1c..f439a361 100644 --- a/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs +++ b/Source/OpenTK/Platform/Windows/WinRawKeyboard.cs @@ -180,31 +180,30 @@ namespace OpenTK.Platform.Windows switch (rin.Data.Keyboard.VKey) { case VirtualKeys.SHIFT: - keyboard[Input.Key.ShiftLeft] = keyboard[Input.Key.ShiftRight] = pressed; + keyboard.SetKeyState(Key.ShiftLeft, (byte)WinGLNative.ShiftLeftScanCode, pressed); + keyboard.SetKeyState(Key.ShiftRight, (byte)WinGLNative.ShiftRightScanCode, pressed); processed = true; break; case VirtualKeys.CONTROL: - keyboard[Input.Key.ControlLeft] = keyboard[Input.Key.ControlRight] = pressed; + keyboard.SetKeyState(Key.ControlLeft, (byte)WinGLNative.ControlLeftScanCode, pressed); + keyboard.SetKeyState(Key.ControlRight, (byte)WinGLNative.ControlRightScanCode, pressed); processed = true; break; case VirtualKeys.MENU: - keyboard[Input.Key.AltLeft] = keyboard[Input.Key.AltRight] = pressed; + keyboard.SetKeyState(Key.AltLeft, (byte)WinGLNative.AltLeftScanCode, pressed); + keyboard.SetKeyState(Key.AltRight, (byte)WinGLNative.AltRightScanCode, pressed); processed = true; break; default: - if (!KeyMap.ContainsKey(rin.Data.Keyboard.VKey)) - { - Debug.Print("Virtual key {0} ({1}) not mapped.", - rin.Data.Keyboard.VKey, (int)rin.Data.Keyboard.VKey); - } - else - { - keyboard[KeyMap[rin.Data.Keyboard.VKey]] = pressed; - processed = true; - } + Key key; + KeyMap.TryGetValue(rin.Data.Keyboard.VKey, out key); + if (key == Key.Unknown) + Debug.Print("Virtual key {0} ({1}) not mapped.", rin.Data.Keyboard.VKey, (int)rin.Data.Keyboard.VKey); + keyboard.SetKeyState(key, BitConverter.GetBytes(rin.Data.Keyboard.MakeCode)[0], pressed); + processed = true; break; } diff --git a/Source/OpenTK/Platform/X11/X11Input.cs b/Source/OpenTK/Platform/X11/X11Input.cs index 10978019..a9193a40 100644 --- a/Source/OpenTK/Platform/X11/X11Input.cs +++ b/Source/OpenTK/Platform/X11/X11Input.cs @@ -157,20 +157,22 @@ namespace OpenTK.Platform.X11 case XEventName.KeyPress: case XEventName.KeyRelease: bool pressed = e.type == XEventName.KeyPress; + XKey keysym = (XKey)API.LookupKeysym(ref e.KeyEvent, 0); + XKey keysym2 = (XKey)API.LookupKeysym(ref e.KeyEvent, 1); + Key key = Key.Unknown; - IntPtr keysym = API.LookupKeysym(ref e.KeyEvent, 0); - IntPtr keysym2 = API.LookupKeysym(ref e.KeyEvent, 1); - - if (keymap.ContainsKey((XKey)keysym)) - keyboard[keymap[(XKey)keysym]] = pressed; - else if (keymap.ContainsKey((XKey)keysym2)) - keyboard[keymap[(XKey)keysym2]] = pressed; + if (keymap.ContainsKey(keysym)) + key = keymap[keysym]; + else if (keymap.ContainsKey(keysym2)) + key = keymap[keysym2]; else Debug.Print("KeyCode {0} (Keysym: {1}, {2}) not mapped.", e.KeyEvent.keycode, (XKey)keysym, (XKey)keysym2); + + keyboard.SetKey(key, (uint)e.KeyEvent.keycode, pressed); break; case XEventName.ButtonPress: - if (e.ButtonEvent.button == 1) mouse[OpenTK.Input.MouseButton.Left] = true; + if (e.ButtonEvent.button == 1) mouse[OpenTK.Input.MouseButton.Left] = true; else if (e.ButtonEvent.button == 2) mouse[OpenTK.Input.MouseButton.Middle] = true; else if (e.ButtonEvent.button == 3) mouse[OpenTK.Input.MouseButton.Right] = true; else if (e.ButtonEvent.button == 4) mouse.Wheel++; @@ -190,7 +192,7 @@ namespace OpenTK.Platform.X11 break; case XEventName.ButtonRelease: - if (e.ButtonEvent.button == 1) mouse[OpenTK.Input.MouseButton.Left] = false; + if (e.ButtonEvent.button == 1) mouse[OpenTK.Input.MouseButton.Left] = false; else if (e.ButtonEvent.button == 2) mouse[OpenTK.Input.MouseButton.Middle] = false; else if (e.ButtonEvent.button == 3) mouse[OpenTK.Input.MouseButton.Right] = false; else if (e.ButtonEvent.button == 6) mouse[OpenTK.Input.MouseButton.Button1] = false;