1
Posted 29 July 2007 - 04:13 PM
KeyboardState keyboard = Keyboard.GetState(); keyboard.IsKeyPressed(Key);There is no way that would ever work..unless i'm suppose to poll every key. the other way was the
keyboard.GetPressedKeys();which doesn't give me help either. There has to be some simple way to get text that the user types in. For example if they wanted to chat..."Hi My name is Kyle"....how would I grab the text that they entered? I hope I made this clear enough.. Thanks, ArchG
Posted 29 July 2007 - 04:17 PM
Posted 20 August 2007 - 10:50 AM
Posted 21 August 2007 - 12:22 PM
Quote:
Original post by NickGravelyn
Something like that is far beyond what XNA is. At it's core XNA is just a fancy wrapper around DirectX and XInput. So yes, you will have to manually check each key and add it to the end of a string. It sucks, but just make it a class that you can reuse and then it won't seem so bad.
Quote:
Original post by ArchG
For example if they wanted to chat..."Hi My name is Kyle"....how would I grab the text that they entered?
Posted 21 August 2007 - 02:55 PM
Quote:
Original post by Thevenin Quote:
Original post by NickGravelyn
Something like that is far beyond what XNA is. At it's core XNA is just a fancy wrapper around DirectX and XInput. So yes, you will have to manually check each key and add it to the end of a string. It sucks, but just make it a class that you can reuse and then it won't seem so bad.
Eh? Even DirectX has support for event based input (kinda; directInput had a toggle to do BufferedInput, which completely solves the cons about poll-based input. Furthermore, DirectX does not have methods to create a Window, DirectX programmers had to create their window with Win32 and then build a DirectX context into it -- XNA does this for you.
Quote:
Currently, XNA sucks for getting input, even for simple games (like Tetris); it's like a trademark suckyness similar to RPGMaker2000 games wherein you find yourself saying "this game must be made in RPGMaker2000 because of {some suckyness}. You can alleviate this by building a event-based system overtop of the poll-based system (shoving the frequncy reader on a seperate thread), but that won't solve all the issues. Lack of event-based input is one of the primary issues I've had with XNA. The best solution thus far is to embed XNA's MDX components into a WinForms application, and use WinForms as the framework for event-based input. This way ditch everything that differentiates XNA from MDX; no more XNA Input, no more XNA Window, and no more XNA Game class. You'll have to resort back to handling your own devicelost exceptions, and the like, just as you would with MDX.
benryves has a couple solutions. One is embedding XNA into a WinForm (which I do aswell), another is a GlobalKeyHook. Considering both of these solutions rely on hacks&/otherwise_abusive_methods I'd go with the WinForms if but for the sole reason that you won't find yourself locked out of other important features (Such as Input Method Editors).
Posted 21 August 2007 - 08:46 PM
namespace Win32
{
public enum VKey
{
// Tons of other VK_ codes removed.
CAPITAL = 0x14,
NUMLOCK = 0x90,
SCROLL = 0x91,
}
public static class User
{
[DllImport("user32.dll")]
public static extern short GetKeyState(VKey vkey);
}
}
public enum KeyState
{
Up, Down, NewUp, NewDown
}
public class KeyboardTracker
{
static TimeSpan keyDelayTime;
static TimeSpan keyRepeatTime;
KeyState[] keyStates;
Keys lastPressedKey;
TimeSpan nextRepeatTime;
int repeatSignal;
bool capsLock;
bool numLock;
bool scrollLock;
public bool AltDown
{
get { return keyStates[(int)Keys.LeftAlt] == KeyState.Down || keyStates[(int)Keys.RightAlt] == KeyState.Down; }
}
public bool CtrlDown
{
get { return keyStates[(int)Keys.LeftControl] == KeyState.Down || keyStates[(int)Keys.RightControl] == KeyState.Down; }
}
public bool ShiftDown
{
get { return keyStates[(int)Keys.LeftShift] == KeyState.Down || keyStates[(int)Keys.RightShift] == KeyState.Down; }
}
public bool CapsLock { get { return capsLock; } }
public bool NumLock { get { return numLock; } }
public bool ScrollLock { get { return scrollLock; } }
public KeyState[] KeyStates
{
get { return keyStates; }
}
public Keys LastPressedKey
{
get { return lastPressedKey; }
}
public int RepeatSignal
{
get { return repeatSignal; }
}
static KeyboardTracker()
{
keyDelayTime = new TimeSpan(0, 0, 0, 0, 250 + 250*SystemInformation.KeyboardDelay);
keyRepeatTime = new TimeSpan(0, 0, 0, 0, 33 + (400-33) * (31 - SystemInformation.KeyboardSpeed) / 31);
}
public KeyboardTracker()
{
Keys[] values = (Keys[])Enum.GetValues(typeof(Keys));
int maxIndex = 0;
foreach (Keys key in values)
{
if ((int)key > maxIndex)
maxIndex = (int)key;
}
lastPressedKey = Keys.None;
keyStates = new KeyState[maxIndex+1];
}
public void Update(GameTime gameTime)
{
KeyState[] tempStates = new KeyState[keyStates.Length];
KeyboardState state = Keyboard.GetState();
capsLock = (Win32.User.GetKeyState(Win32.VKey.CAPITAL) & 1) != 0;
numLock = (Win32.User.GetKeyState(Win32.VKey.NUMLOCK) & 1) != 0;
scrollLock = (Win32.User.GetKeyState(Win32.VKey.SCROLL) & 1) != 0;
Keys[] keys = state.GetPressedKeys();
for (int i=0; i<keys.Length; ++i)
{
tempStates[(int)keys[i]] = KeyState.Down;
}
repeatSignal = 0;
for (int i=0; i<keyStates.Length; ++i)
{
switch (keyStates[i])
{
case KeyState.Up:
if (tempStates[i] == KeyState.Down) keyStates[i] = KeyState.NewDown;
break;
case KeyState.Down:
if (tempStates[i] == KeyState.Up) keyStates[i] = KeyState.NewUp;
break;
case KeyState.NewDown:
if (tempStates[i] == KeyState.Down) keyStates[i] = KeyState.Down;
else keyStates[i] = KeyState.NewUp;
break;
case KeyState.NewUp:
if (tempStates[i] == KeyState.Up) keyStates[i] = KeyState.Up;
else keyStates[i] = KeyState.NewDown;
break;
}
if (keyStates[i] == KeyState.NewDown)
{
Keys newPressedKey = (Keys)i;
if (newPressedKey != lastPressedKey)
{
nextRepeatTime = gameTime.TotalRealTime + keyDelayTime;
repeatSignal = 1;
}
lastPressedKey = newPressedKey;
}
}
if (keyStates[(int)lastPressedKey] == KeyState.Up || keyStates[(int)lastPressedKey] == KeyState.NewUp)
{
lastPressedKey = Keys.None;
}
else
{
while (gameTime.TotalRealTime > nextRepeatTime)
{
repeatSignal++;
nextRepeatTime += keyRepeatTime;
}
}
}
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 class KeyEventArgs
{
public bool capsLock;
public bool numLock;
public bool scrollLock;
public bool alt;
public bool ctrl;
public bool shift;
public char character;
public readonly Keys key;
public KeyEventArgs(Keys key, bool alt, bool ctrl, bool shift, bool capsLock, bool numLock, bool scrollLock)
{
this.key = key;
this.alt = alt;
this.ctrl = ctrl;
this.shift = shift;
this.capsLock = capsLock;
this.numLock = numLock;
this.scrollLock = scrollLock;
character = KeyboardTracker.TranslateChar(key, shift, capsLock, numLock);
}
}
public class KeyPressEventArgs
{
public bool handled;
public char keychar;
public Keys key;
public KeyPressEventArgs(Keys key, char keychar)
{
this.key = key;
this.keychar = keychar;
}
}
public class PreviewKeyDownEventArgs
{
KeyEventArgs kea;
bool isInputKey;
public KeyEventArgs KeyEventArgs
{
get { return kea; }
}
public bool IsInputKey
{
get { return isInputKey; }
set { isInputKey = value; }
}
public PreviewKeyDownEventArgs(KeyEventArgs kea)
{
this.kea = kea;
}
}
public delegate void KeyEventHandler(object sender, KeyEventArgs kea);
public delegate void KeyPressEventHandler(object sender, KeyPressEventArgs kea);
public delegate void PreviewKeyDownEventHandler(object sender, PreviewKeyDownEventArgs pkea);
// The following code is snippets from class 'GuiManager'
// (which has so many other methods that I just ripped the keyboard functions out by themselves).
// The GuiManager is a class derived from a System.Windows.Forms.Control look-alike class
// from which I derive everything in my GUI system. The GuiManager originally was
// a stand-alone class, but composite child control handling led me to just derive
// from the Control class instead.
// An important part to note is that UpdateKeyboard should only be called
// if the application window has focus / is active.
KeyboardTracker keyboardTracker;
void UpdateKeyboard(GameTime gameTime)
{
keyboardTracker.Update(gameTime);
if (focusControl != null)
{
for (int i=0; i<keyboardTracker.KeyStates.Length; ++i)
{
switch (keyboardTracker.KeyStates[i])
{
case KeyState.NewUp:
OnKeyUp(new KeyEventArgs((Keys)i, keyboardTracker.AltDown, keyboardTracker.CtrlDown, keyboardTracker.ShiftDown,
keyboardTracker.CapsLock, keyboardTracker.NumLock, keyboardTracker.ScrollLock));
break;
case KeyState.NewDown:
if (keyboardTracker.LastPressedKey != (Keys)i) // Prevent two KeyDowns for the newest key.
{
OnKeyDown(new KeyEventArgs((Keys)i, keyboardTracker.AltDown, keyboardTracker.CtrlDown, keyboardTracker.ShiftDown,
keyboardTracker.CapsLock, keyboardTracker.NumLock, keyboardTracker.ScrollLock));
}
break;
}
}
// Key Repeats
if (keyboardTracker.LastPressedKey != Keys.None)
{
char character = KeyboardTracker.TranslateChar(
keyboardTracker.LastPressedKey, keyboardTracker.ShiftDown, keyboardTracker.CapsLock, keyboardTracker.NumLock);
for (int i=0; i<keyboardTracker.RepeatSignal; ++i)
{
OnKeyDown(new KeyEventArgs(keyboardTracker.LastPressedKey, keyboardTracker.AltDown, keyboardTracker.CtrlDown, keyboardTracker.ShiftDown,
keyboardTracker.CapsLock, keyboardTracker.NumLock, keyboardTracker.ScrollLock));
if (character != '\0')
{
OnKeyPress(new KeyPressEventArgs(keyboardTracker.LastPressedKey, character));
}
}
}
}
}
public override void OnKeyUp(KeyEventArgs kea)
{
if (focusControl.IsInputKey(kea.key))
{
focusControl.OnKeyUp(kea);
}
}
public override void OnKeyDown(KeyEventArgs kea)
{
if (focusControl.IsInputKey(kea.key))
{
focusControl.OnKeyDown(kea);
}
else
{
if (kea.key == Keys.Tab)
{
Control newTabStop = GetNextTabStop(focusControl, !kea.shift);
if (newTabStop != null)
{
Focus = newTabStop;
}
}
}
}
public override void OnKeyPress(KeyPressEventArgs kpea)
{
if (focusControl.IsInputKey(kpea.key))
{
focusControl.OnKeyPress(kpea);
}
}
Posted 21 August 2007 - 09:44 PM
using System;
using System.Runtime.InteropServices;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
namespace EventInput
{
public class CharacterEventArgs : EventArgs
{
private readonly char character;
private readonly int lParam;
public CharacterEventArgs( char character, int lParam )
{
this.character = character;
this.lParam = lParam;
}
public char Character
{
get { return character; }
}
public int Param
{
get { return lParam; }
}
public int RepeatCount
{
get { return lParam & 0xffff; }
}
public bool ExtendedKey
{
get { return ( lParam & ( 1 << 24 ) ) > 0; }
}
public bool AltPressed
{
get { return ( lParam & ( 1 << 29 ) ) > 0; }
}
public bool PreviousState
{
get { return ( lParam & ( 1 << 30 ) ) > 0; }
}
public bool TransitionState
{
get { return ( lParam & ( 1 << 31 ) ) > 0; }
}
}
public class KeyEventArgs : EventArgs
{
private Keys keyCode;
public KeyEventArgs( Keys keyCode )
{
this.keyCode = keyCode;
}
public Keys KeyCode
{
get { return keyCode; }
}
}
public delegate void CharEnteredHandler( object sender, CharacterEventArgs e );
public delegate void KeyEventHandler( object sender, KeyEventArgs e );
public static class EventInput
{
/// <summary>
/// Event raised when a character has been entered.
/// </summary>
public static event CharEnteredHandler CharEntered;
/// <summary>
/// Event raised when a key has been pressed down. May fire multiple times due to keyboard repeat.
/// </summary>
public static event KeyEventHandler KeyDown;
/// <summary>
/// Event raised when a key has been released.
/// </summary>
public static event KeyEventHandler KeyUp;
delegate IntPtr WndProc( IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam );
static bool initialized;
static IntPtr prevWndProc;
static WndProc hookProcDelegate;
static IntPtr hIMC;
//various Win32 constants that we need
const int GWL_WNDPROC = -4;
const int WM_KEYDOWN = 0x100;
const int WM_KEYUP = 0x101;
const int WM_CHAR = 0x102;
const int WM_IME_SETCONTEXT = 0x0281;
const int WM_INPUTLANGCHANGE = 0x51;
const int WM_GETDLGCODE = 0x87;
const int WM_IME_COMPOSITION = 0x10f;
const int DLGC_WANTALLKEYS = 4;
//Win32 functions that we're using
[DllImport( "Imm32.dll" )]
static extern IntPtr ImmGetContext( IntPtr hWnd );
[DllImport( "Imm32.dll" )]
static extern IntPtr ImmAssociateContext( IntPtr hWnd, IntPtr hIMC );
[DllImport( "user32.dll" )]
static extern IntPtr CallWindowProc( IntPtr lpPrevWndFunc, IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam );
[DllImport( "user32.dll" )]
static extern int SetWindowLong( IntPtr hWnd, int nIndex, int dwNewLong );
/// <summary>
/// Initialize the TextInput with the given GameWindow.
/// </summary>
/// <param name="window">The XNA window to which text input should be linked.</param>
public static void Initialize( GameWindow window )
{
if( initialized )
throw new InvalidOperationException( "TextInput.Initialize can only be called once!" );
hookProcDelegate = new WndProc( HookProc );
prevWndProc = (IntPtr) SetWindowLong( window.Handle, GWL_WNDPROC,
(int) Marshal.GetFunctionPointerForDelegate( hookProcDelegate ) );
hIMC = ImmGetContext( window.Handle );
initialized = true;
}
static IntPtr HookProc( IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam )
{
IntPtr returnCode = CallWindowProc( prevWndProc, hWnd, msg, wParam, lParam );
switch( msg )
{
case WM_GETDLGCODE:
returnCode = (IntPtr) ( returnCode.ToInt32() | DLGC_WANTALLKEYS );
break;
case WM_KEYDOWN:
if( KeyDown != null )
KeyDown( null, new KeyEventArgs( (Keys) wParam ) );
break;
case WM_KEYUP:
if( KeyUp != null )
KeyUp( null, new KeyEventArgs( (Keys) wParam ) );
break;
case WM_CHAR:
if( CharEntered != null )
CharEntered( null, new CharacterEventArgs( (char) wParam, lParam.ToInt32() ) );
break;
case WM_IME_SETCONTEXT:
if( wParam.ToInt32() == 1 )
ImmAssociateContext( hWnd, hIMC );
break;
case WM_INPUTLANGCHANGE:
ImmAssociateContext( hWnd, hIMC );
returnCode = (IntPtr) 1;
break;
}
return returnCode;
}
}
}
Posted 24 August 2007 - 09:14 AM
Posted 24 August 2007 - 09:50 AM
Posted 24 August 2007 - 05:22 PM
using System;
using System.Runtime.InteropServices;
namespace Microsoft.Xna.Framework.Input
{
public class CharacterEventArgs : EventArgs
{
private readonly char character;
private readonly int lParam;
public CharacterEventArgs(char character, int lParam)
{
this.character = character;
this.lParam = lParam;
}
public char Character
{
get { return character; }
}
public int Param
{
get { return lParam; }
}
public int RepeatCount
{
get { return lParam & 0xffff; }
}
public bool ExtendedKey
{
get { return (lParam & (1 << 24)) > 0; }
}
public bool AltPressed
{
get { return (lParam & (1 << 29)) > 0; }
}
public bool PreviousState
{
get { return (lParam & (1 << 30)) > 0; }
}
public bool TransitionState
{
get { return (lParam & (1 << 31)) > 0; }
}
}
public class KeyEventArgs : EventArgs
{
private Keys keyCode;
public KeyEventArgs(Keys keyCode)
{
this.keyCode = keyCode;
}
public Keys KeyCode
{
get { return keyCode; }
}
}
public class MouseEventArgs : EventArgs
{
private MouseButton button;
private int clicks;
private int x;
private int y;
private int delta;
public MouseButton Button { get { return button; } }
public int Clicks { get { return clicks; } }
public int X { get { return x; } }
public int Y { get { return y; } }
public Point Location { get { return new Point(x,y); } }
public int Delta { get { return delta; } }
public MouseEventArgs(MouseButton button, int clicks, int x, int y, int delta)
{
this.button = button;
this.clicks = clicks;
this.x = x;
this.y = y;
this.delta = delta;
}
}
public delegate void CharEnteredHandler(object sender, CharacterEventArgs e);
public delegate void KeyEventHandler(object sender, KeyEventArgs e);
public delegate void MouseEventHandler(object sender, MouseEventArgs e);
/// <summary>
/// Mouse Key Flags from WinUser.h for mouse related WM messages.
/// </summary>
[Flags]
public enum MouseKeys
{
LButton = 0x01,
RButton = 0x02,
Shift = 0x04,
Control = 0x08,
MButton = 0x10,
XButton1 = 0x20,
XButton2 = 0x40
}
public enum MouseButton
{
None, Left, Right, Middle, X1, X2
}
public static class InputSystem
{
#region Events
/// <summary>
/// Event raised when a character has been entered.
/// </summary>
public static event CharEnteredHandler CharEntered;
/// <summary>
/// Event raised when a key has been pressed down. May fire multiple times due to keyboard repeat.
/// </summary>
public static event KeyEventHandler KeyDown;
/// <summary>
/// Event raised when a key has been released.
/// </summary>
public static event KeyEventHandler KeyUp;
/// <summary>
/// Event raised when a mouse button is pressed.
/// </summary>
public static event MouseEventHandler MouseDown;
/// <summary>
/// Event raised when a mouse button is released.
/// </summary>
public static event MouseEventHandler MouseUp;
/// <summary>
/// Event raised when the mouse changes location.
/// </summary>
public static event MouseEventHandler MouseMove;
/// <summary>
/// Event raised when the mouse has hovered in the same location for a short period of time.
/// </summary>
public static event MouseEventHandler MouseHover;
/// <summary>
/// Event raised when the mouse wheel has been moved.
/// </summary>
public static event MouseEventHandler MouseWheel;
/// <summary>
/// Event raised when a mouse button has been double clicked.
/// </summary>
public static event MouseEventHandler MouseDoubleClick;
#endregion
delegate IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);
static bool initialized;
static IntPtr prevWndProc;
static WndProc hookProcDelegate;
static IntPtr hIMC;
#region Win32 Constants
const int GWL_WNDPROC = -4;
const int WM_KEYDOWN = 0x100;
const int WM_KEYUP = 0x101;
const int WM_CHAR = 0x102;
const int WM_IME_SETCONTEXT = 0x281;
const int WM_INPUTLANGCHANGE = 0x51;
const int WM_GETDLGCODE = 0x87;
const int WM_IME_COMPOSITION = 0x10F;
const int DLGC_WANTALLKEYS = 4;
const int WM_MOUSEMOVE = 0x200;
const int WM_LBUTTONDOWN = 0x201;
const int WM_LBUTTONUP = 0x202;
const int WM_LBUTTONDBLCLK = 0x203;
const int WM_RBUTTONDOWN = 0x204;
const int WM_RBUTTONUP = 0x205;
const int WM_RBUTTONDBLCLK = 0x206;
const int WM_MBUTTONDOWN = 0x207;
const int WM_MBUTTONUP = 0x208;
const int WM_MBUTTONDBLCLK = 0x209;
const int WM_MOUSEWHEEL = 0x20A;
const int WM_XBUTTONDOWN = 0x20B;
const int WM_XBUTTONUP = 0x20C;
const int WM_XBUTTONDBLCLK = 0x20D;
const int WM_MOUSEHOVER = 0x2A1;
#endregion
#region DLL Imports
[DllImport("Imm32.dll")]
static extern IntPtr ImmGetContext(IntPtr hWnd);
[DllImport("Imm32.dll")]
static extern IntPtr ImmAssociateContext(IntPtr hWnd, IntPtr hIMC);
[DllImport("user32.dll")]
static extern IntPtr CallWindowProc(IntPtr lpPrevWndFunc, IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll")]
static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
#endregion
public static Point MouseLocation
{
get
{
MouseState state = Mouse.GetState();
return new Point(state.X, state.Y);
}
}
public static bool ShiftDown
{
get
{
KeyboardState state = Keyboard.GetState();
return state.IsKeyDown(Keys.LeftShift) || state.IsKeyDown(Keys.RightShift);
}
}
public static bool CtrlDown
{
get
{
KeyboardState state = Keyboard.GetState();
return state.IsKeyDown(Keys.LeftControl) || state.IsKeyDown(Keys.RightControl);
}
}
public static bool AltDown
{
get
{
KeyboardState state = Keyboard.GetState();
return state.IsKeyDown(Keys.LeftAlt) || state.IsKeyDown(Keys.RightAlt);
}
}
/// <summary>
/// Initialize the TextInput with the given GameWindow.
/// </summary>
/// <param name="window">The XNA window to which text input should be linked.</param>
public static void Initialize(GameWindow window)
{
if (initialized)
throw new InvalidOperationException("TextInput.Initialize can only be called once!");
hookProcDelegate = new WndProc(HookProc);
prevWndProc = (IntPtr)SetWindowLong(window.Handle, GWL_WNDPROC, (int)Marshal.GetFunctionPointerForDelegate(hookProcDelegate));
hIMC = ImmGetContext(window.Handle);
initialized = true;
}
static IntPtr HookProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
IntPtr returnCode = CallWindowProc(prevWndProc, hWnd, msg, wParam, lParam);
switch (msg)
{
case WM_GETDLGCODE:
returnCode = (IntPtr)(returnCode.ToInt32() | DLGC_WANTALLKEYS);
break;
case WM_KEYDOWN:
if (KeyDown != null)
KeyDown(null, new KeyEventArgs((Keys)wParam));
break;
case WM_KEYUP:
if (KeyUp != null)
KeyUp(null, new KeyEventArgs((Keys)wParam));
break;
case WM_CHAR:
if (CharEntered != null)
CharEntered(null, new CharacterEventArgs((char)wParam, lParam.ToInt32()));
break;
case WM_IME_SETCONTEXT:
if (wParam.ToInt32() == 1)
ImmAssociateContext(hWnd, hIMC);
break;
case WM_INPUTLANGCHANGE:
ImmAssociateContext(hWnd, hIMC);
returnCode = (IntPtr)1;
break;
// Mouse messages
case WM_MOUSEMOVE:
if (MouseMove != null)
{
short x, y;
MouseLocationFromLParam(lParam.ToInt32(), out x, out y);
MouseMove(null, new MouseEventArgs(MouseButton.None, 0, x, y, 0));
}
break;
case WM_MOUSEHOVER:
if (MouseHover != null)
{
short x, y;
MouseLocationFromLParam(lParam.ToInt32(), out x, out y);
MouseHover(null, new MouseEventArgs(MouseButton.None, 0, x, y, 0));
}
break;
case WM_MOUSEWHEEL:
if (MouseWheel != null)
{
short x, y;
MouseLocationFromLParam(lParam.ToInt32(), out x, out y);
MouseWheel(null, new MouseEventArgs(MouseButton.None, 0, x, y, (wParam.ToInt32() >> 16) / 120));
}
break;
case WM_LBUTTONDOWN: RaiseMouseDownEvent (MouseButton.Left, wParam.ToInt32(), lParam.ToInt32()); break;
case WM_LBUTTONUP: RaiseMouseUpEvent (MouseButton.Left, wParam.ToInt32(), lParam.ToInt32()); break;
case WM_LBUTTONDBLCLK: RaiseMouseDblClickEvent(MouseButton.Left, wParam.ToInt32(), lParam.ToInt32()); break;
case WM_RBUTTONDOWN: RaiseMouseDownEvent (MouseButton.Right, wParam.ToInt32(), lParam.ToInt32()); break;
case WM_RBUTTONUP: RaiseMouseUpEvent (MouseButton.Right, wParam.ToInt32(), lParam.ToInt32()); break;
case WM_RBUTTONDBLCLK: RaiseMouseDblClickEvent(MouseButton.Right, wParam.ToInt32(), lParam.ToInt32()); break;
case WM_MBUTTONDOWN: RaiseMouseDownEvent (MouseButton.Middle, wParam.ToInt32(), lParam.ToInt32()); break;
case WM_MBUTTONUP: RaiseMouseUpEvent (MouseButton.Middle, wParam.ToInt32(), lParam.ToInt32()); break;
case WM_MBUTTONDBLCLK: RaiseMouseDblClickEvent(MouseButton.Middle, wParam.ToInt32(), lParam.ToInt32()); break;
case WM_XBUTTONDOWN:
if ((wParam.ToInt32() & 0x10000) != 0)
{
RaiseMouseDownEvent(MouseButton.X1, wParam.ToInt32(), lParam.ToInt32());
}
else if ((wParam.ToInt32() & 0x20000) != 0)
{
RaiseMouseDownEvent(MouseButton.X2, wParam.ToInt32(), lParam.ToInt32());
}
break;
case WM_XBUTTONUP:
if ((wParam.ToInt32() & 0x10000) != 0)
{
RaiseMouseUpEvent(MouseButton.X1, wParam.ToInt32(), lParam.ToInt32());
}
else if ((wParam.ToInt32() & 0x20000) != 0)
{
RaiseMouseUpEvent(MouseButton.X2, wParam.ToInt32(), lParam.ToInt32());
}
break;
case WM_XBUTTONDBLCLK:
if ((wParam.ToInt32() & 0x10000) != 0)
{
RaiseMouseDblClickEvent(MouseButton.X1, wParam.ToInt32(), lParam.ToInt32());
}
else if ((wParam.ToInt32() & 0x20000) != 0)
{
RaiseMouseDblClickEvent(MouseButton.X2, wParam.ToInt32(), lParam.ToInt32());
}
break;
}
return returnCode;
}
#region Mouse Message Helpers
static void RaiseMouseDownEvent(MouseButton button, int wParam, int lParam)
{
if (MouseDown != null)
{
short x, y;
MouseLocationFromLParam(lParam, out x, out y);
MouseDown(null, new MouseEventArgs(button, 1, x, y, 0));
}
}
static void RaiseMouseUpEvent(MouseButton button, int wParam, int lParam)
{
if (MouseUp != null)
{
short x, y;
MouseLocationFromLParam(lParam, out x, out y);
MouseUp(null, new MouseEventArgs(button, 1, x, y, 0));
}
}
static void RaiseMouseDblClickEvent(MouseButton button, int wParam, int lParam)
{
if (MouseDoubleClick != null)
{
short x, y;
MouseLocationFromLParam(lParam, out x, out y);
MouseDoubleClick(null, new MouseEventArgs(button, 1, x, y, 0));
}
}
static void MouseLocationFromLParam(int lParam, out short x, out short y)
{
// Cast to signed shorts to get sign extension on negative coordinates (of course this would only be possible if mouse capture was enabled).
x = (short)(lParam & 0xFFFF);
y = (short)(lParam >> 16);
}
#endregion
}
}
Posted 05 September 2007 - 05:04 AM
Posted 05 September 2007 - 05:18 AM
Posted 05 September 2007 - 06:19 AM
#define VK_SHIFT 0x10
.
.
.
/*
* VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
* Used only as parameters to GetAsyncKeyState() and GetKeyState().
* No other API or message will distinguish left and right keys in this way.
*/
#define VK_LSHIFT 0xA0
#define VK_RSHIFT 0xA1
#define VK_LCONTROL 0xA2
#define VK_RCONTROL 0xA3
#define VK_LMENU 0xA4
#define VK_RMENU 0xA5
Posted 05 September 2007 - 06:40 AM
Quote:
Original post by mydevnull
Okay, did it the following way:
