gxinput.cs

功能：基于windows mobile 的地图查看器。使用vs2005开发

using System;
using System.Data;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Collections;


namespace GXInputLibrary
{
	/// <summary>
	/// Class responsible for handling all input.
	/// </summary>
	public class GXInput
	{
		public ArrayList HardwareKeys { get { return m_hardwareKeys; } }
		protected ArrayList m_hardwareKeys = new ArrayList(7);


		/// <summary>
		/// Bitmask used to access if a button is currently pressed.
		/// </summary>
		protected const byte kDownMask = 0x01;
		
		/// <summary>
		/// Equal to ~kDownMask.
		/// </summary>
		protected const byte kNotDownMask = 0xfe;

		/// <summary>
		/// Bitmask used to access if a button has been pressed and released.
		/// </summary>
		protected const byte kPressedMask = 0x02;
		
		/// <summary>
		/// Equal to ~kPressedMask.
		/// </summary>
		protected const byte kNotPressedMask = 0xfd;

		/// <summary>
		/// Bitmask used to determine if a button is registered.
		/// </summary>
		protected const byte kRegisteredMask = 0x80;

		/// <summary>
		/// Equal to ~kRegisteredMask.
		/// </summary>
		protected const byte kNotRegisteredMask = 0x7f;

		/// <summary>
		/// Number of keys to track.
		/// </summary>
		protected const int kNumKeys = 256;

		/// <summary>
		/// Array of key states.  These states are tracked using the various bitmasks
		/// defined in this class.
		/// </summary>
		protected byte[] m_keyStates = new byte[kNumKeys];

		/// <summary>
		/// MessageWindow instance used by GXInput to intercept hardware button presses.
		/// </summary>
		protected Control m_msgWindow = null;

		/// <summary>
		/// Creates an instance of GXInput.
		/// </summary>
		public GXInput(Control ctrl)
		{
            m_msgWindow = ctrl;
			m_msgWindow.KeyDown +=new KeyEventHandler(m_msgWindow_KeyDown);
			m_msgWindow.KeyUp +=new KeyEventHandler(m_msgWindow_KeyUp);

#if SMARTPHONE
			m_hardwareKeys.Add(193);
			m_hardwareKeys.Add(112);
			m_hardwareKeys.Add(113);
			m_hardwareKeys.Add(198);
			m_hardwareKeys.Add(197);
			m_hardwareKeys.Add(27);
			m_hardwareKeys.Add(13);
#elif MAINSTONE
			m_hardwareKeys.Add(35);  // quit
			m_hardwareKeys.Add(8);   // reset
			m_hardwareKeys.Add(Keys.A); // debug switch
			m_hardwareKeys.Add(43);  // shoot
			m_hardwareKeys.Add(197);
#elif DESKTOP
			m_hardwareKeys.Add(Keys.Q);
			m_hardwareKeys.Add(Keys.W);
			m_hardwareKeys.Add(Keys.A);
			m_hardwareKeys.Add(Keys.S);
			m_hardwareKeys.Add(Keys.D);
#else // PPC
			m_hardwareKeys.Add(193);
			m_hardwareKeys.Add(194);
			m_hardwareKeys.Add(195);
			m_hardwareKeys.Add(196);
			m_hardwareKeys.Add(197);
#endif

			// Initialize each key state
			for (int i = 0; i < kNumKeys; i++)
			{
				m_keyStates[i] = 0x00;
			}
		}

		/// <summary>
		/// Register all of the hardware keys, including the directional pad.
		/// It is required to register a key in order to receive state information on it.
		/// </summary>
		public void RegisterAllHardwareKeys()
		{
			foreach (int i in m_hardwareKeys)
			{
				RegisterKey(i);
			}

			RegisterKey((int)Keys.Up);
			RegisterKey((int)Keys.Down);
			RegisterKey((int)Keys.Left);
			RegisterKey((int)Keys.Right);
		}

		/// <summary>
		/// Register every possible key. It is required to register a key in order
		/// to receive state information on it.
		/// </summary>
		public void RegisterAllKeys()
		{
			for (int i = 0; i < kNumKeys; i++)
			{
				RegisterKey(i);
			}
		}

		/// <summary>
		/// Unregister all of the hardware keys, including the directional pad.
		/// </summary>
		public void UnregisterAllHardwareKeys()
		{
			foreach (int i in m_hardwareKeys)
			{
				UnregisterKey(i);
			}

			UnregisterKey((int)Keys.Up);
			UnregisterKey((int)Keys.Down);
			UnregisterKey((int)Keys.Left);
			UnregisterKey((int)Keys.Right);
		}

		/// <summary>
		/// Unregister every key.
		/// </summary>
		public void UnegisterAllKeys()
		{
			for (int i = 0; i < kNumKeys; i++)
			{
				UnregisterKey(i);
			}
		}

		/// <summary>
		/// Register the key specified for input.
		/// </summary>
		/// <param name="vKey">Virtual key code</param>
		public void RegisterKey(int vKey)
		{
			m_keyStates[vKey] |= kRegisteredMask;
		}

		/// <summary>
		/// Unregister the key specified.
		/// </summary>
		/// <param name="vKey">Virtual key code</param>
		public void UnregisterKey(int vKey)
		{
			m_keyStates[vKey] &= kNotRegisteredMask;
		}

		/// <summary>
		/// Check if any registered key has been pressed
		/// </summary>
		/// <param name="vKey">Virtual key code</param>
		/// <returns>true if any registered key is down</returns>
		public bool AnyKeyPressed()
		{
			for(int i = 0; i < m_keyStates.Length; i++)
			{
				if (((m_keyStates[i] & kRegisteredMask) != 0) &&
					((m_keyStates[i] & kPressedMask) != 0) )
				{
					return true;
				}
			}

			return false;
		}

		/// <summary>
		/// Clears any existing key presses so that KeyPressed()
		/// and AnyKeyPressed() will return false until a new key
		/// has been pressed
		/// </summary>
		public void ClearKeyPresses()
		{
			for(int i = 0; i < m_keyStates.Length; i++)
				m_keyStates[i] &= kNotPressedMask;
		}

		/// <summary>
		/// Check if the key has been pressed and released since the last
		/// call to this function.
		/// </summary>
		/// <param name="vKey">Virtual key code</param>
		/// <returns>true if the key has been pressed and released
		/// since the last call to this function</returns>
		public bool KeyPressed(int vKey)
		{
			if((m_keyStates[vKey] & kPressedMask) != 0)
			{
				m_keyStates[vKey] &= kNotPressedMask;
				return true;
			}

			return false;
		}


		/// <summary>
		/// Check if the key is currently down.
		/// </summary>
		/// <param name="vKey">Virtual key code</param>
		/// <returns>true if down, false otherwise</returns>
		public bool KeyDown(int vKey)
		{
			if ((m_keyStates[vKey] & kDownMask) != 0)
				return true;

			return false;
		}

		/// <summary>
		/// Check if the key is currently released.
		/// </summary>
		/// <param name="vKey">Virtual key code</param>
		/// <returns>true if released, false otherwise</returns>
		public bool KeyReleased(int vKey)
		{
			if ((m_keyStates[vKey] & kDownMask) == 0)
				return true;

			return false;
		}

		private void m_msgWindow_KeyDown(object sender, KeyEventArgs e)
		{
          m_keyStates[e.KeyValue] |= kDownMask;
		}

		private void m_msgWindow_KeyUp(object sender, KeyEventArgs e)
		{
			if((m_keyStates[e.KeyValue] & kDownMask) != 0)
				m_keyStates[e.KeyValue] |= kPressedMask;
			m_keyStates[e.KeyValue] &= kNotDownMask;
		}
	}
}