internal RawStylusInputReport(
            InputMode mode,
            int timestamp,
            PresentationSource inputSource,
            PenContext penContext,
            RawStylusActions actions,
            int tabletDeviceId,
            int stylusDeviceId,
            int[] data)
            : base(inputSource, InputType.Stylus, mode, timestamp)
        {
            // Validate parameters
            if (!RawStylusActionsHelper.IsValid(actions))
            {
                throw new InvalidEnumArgumentException(SR.Get(SRID.Enum_Invalid, "actions"));
            }
            if (data == null && actions != RawStylusActions.InRange)
            {
                throw new ArgumentNullException("data");
            }

            _penContext     = new SecurityCriticalDataClass<PenContext>(penContext);
            _actions        = actions;
            _tabletDeviceId = tabletDeviceId;
            _stylusDeviceId = stylusDeviceId;
            _data           = data;
            _isSynchronize  = false;
        }

 void getMove()
 {
     move = false;
     if (Input.GetKeyDown(KeyCode.M)){
         input = "M";
         move = true;
         mode = InputMode.getRoom;
         }
     if (Input.GetKeyDown(KeyCode.S)){
         input = "S";
         move = true;
         mode = InputMode.getArrowPath;
         }
     if (Input.GetKeyDown(KeyCode.Q)){
         input = "Q";
         move = true;
         }
     //clear everything
     if (move){
         selectedRoom = null;
         arrowPath = null;
         tempPath.Clear();
         move = false;
         }
 }

 public CharacterMapKeysAttribute(InputMode mode, string charList, int width, params Key[] keys)
 {
     _mode = mode;
     _charList = charList;
     _width = width;
     _keys = keys;
 }

		/// <summary>
		/// Specifies the input mode on a Smartphone.
		/// </summary>
		public static void SetInputMode(Control control, InputMode mode)
		{
			int msg;

			//only certain controls are supported
			if(control is TextBox)
			{
				msg = EM_SETINPUTMODE; 
			}
			else if(control is ComboBox)
			{
				msg = LB_SETINPUTMODE;
			}
			else
			{
				return;
			}

			//get the handle to the child (native) control
			control.Capture = true;
			IntPtr hwnd = Win32Window.GetWindow(Win32Window.GetCapture(), GW.CHILD);
			control.Capture = false;			

			//send message
			IntPtr result = Win32Window.SendMessage(hwnd, msg, IntPtr.Zero, (int)mode);
		}

 public void ChangeMode(InputMode mode)
 {
     var member = GetType().GetField(string.Format("_{0}Dict", mode.ToString().ToLower()), BindingFlags.NonPublic | BindingFlags.Instance);
     if (member == null) throw new Exception(mode + " does not have a dictionary set up");
     _currentDict = (SequencedDictionary<Key, Message>)member.GetValue(this);
     InputMode = mode;
 }

        public InputHelper(InputMode inputDevice = InputMode.KeyMouse)
        {
            this.inputDevice = inputDevice;

            currentControlerState = GamePad.GetState(PlayerIndex.One);
            currentKeyboardState = Keyboard.GetState();
            currentMouseState = Mouse.GetState();
        }

        protected UIMapControlInputHandler(InputMode setInputMode, UIMapControl setUIMapControl)
        {
            mapUnitOrder = MapUnitOrder.None;
             IsSpanningRectangle = false;
             selectionRectangle = RectangleF.Empty;

             MapControl = setUIMapControl;
             InputMode = setInputMode;
        }

    public void ActivateAttackModifier()
    {
        Debug.Log("attc md activated");
        m_InputMode = InputMode.attack;
        attackModifier = true;
        Cursor.SetCursor(attackCursorTexture, Vector2.zero, CursorMode.Auto);

        Input.ResetInputAxes();
    }

    void Update()
    {
        if (Input.GetButtonDown ("Fire1")) {
            RaycastManager.RaycastControl ();
        }

        if (GameManager.CellControlled == null)
        {
            mode = InputMode.Default;
            return;
        }

        if (GameManager.CellControlled.GetComponent<AgentLife> ().isInfected)
        {
            DeselectAll();
            return;
        }

        if (Input.GetButtonDown ("Fire2")) {
            playerTarget = RaycastManager.RaycastAttackEnemy ();
            GameManager.CellControlled.GetComponent<AgentMovement> ().enabled = false;
            GameManager.CellControlled.GetComponent<MoveToPoint> ().DefineNewDestination (Camera.main.ScreenToWorldPoint (Input.mousePosition));

            if (playerTarget != null) {
                mode = InputMode.Attacking;
            }
            else
            {
                mode = InputMode.Controlling;
            }

        }

        switch (mode) {

        case (InputMode.Attacking):

            if(playerTarget == null)
            {
                //GameManager.CellControlled.GetComponent<AgentMovement> ().enabled = true;
                mode = InputMode.Controlling;
                break;
            }

            GameManager.CellControlled.GetComponent<MoveToPoint> ().DefineNewDestination (playerTarget.transform.position);

            if (Vector2.Distance (GameManager.CellControlled.transform.position, playerTarget.transform.position) < 10) {
                GameManager.CellControlled.GetComponent<AgentMovement> ().enabled = true;
                GameManager.CellControlled.GetComponent<MoveToPoint> ().enabled = false;

            }

            break;

        //case (InputMode.Attacking)
        }
    }

        public InputController(InputMode mode)
        {
            m_Mode = mode;
            m_oldState = new KeyboardState();
            m_newState = new KeyboardState();

            m_oldControllerState = new GamePadState[NUM_SUPPORTED_PLAYERS];
            m_newControllerState = new GamePadState[NUM_SUPPORTED_PLAYERS];
        }

        public HexagonyEnv(string source, string input, HexagonySettings settings)
        {
            if (source.StartsWith("❢"))
                _linearCode = source.Substring(1);
            else
            {
                _grid = Grid.Parse(source);
                _ips = Ut.NewArray(
                    new PointAxial(0, -_grid.Size + 1),
                    new PointAxial(_grid.Size - 1, -_grid.Size + 1),
                    new PointAxial(_grid.Size - 1, 0),
                    new PointAxial(0, _grid.Size - 1),
                    new PointAxial(-_grid.Size + 1, _grid.Size - 1),
                    new PointAxial(-_grid.Size + 1, 0));
                _ipDirs = Ut.NewArray(
                    Direction.East,
                    Direction.SouthEast,
                    Direction.SouthWest,
                    Direction.West,
                    Direction.NorthWest,
                    Direction.NorthEast);
            }
            switch (_inputMode = settings.InputMode)
            {
                case InputMode.Utf8:
                    _input = input.ToUtf8();
                    break;

                case InputMode.Utf16:
                    _input = input.ToUtf16();
                    break;

                case InputMode.Numbers:
                    var m = Regex.Match(input, @"\A(\s*\d+\s*)*\Z", RegexOptions.Singleline);
                    if (!m.Success)
                        throw new InvalidOperationException("The input provided is not a whitespace-separated list of numbers.");
                    _input = m.Groups[1].Captures.Cast<Capture>().Select(c =>
                    {
                        byte b;
                        if (!byte.TryParse(c.Value.Trim(), out b))
                            throw new InvalidOperationException("The number {0} in the input string does not fit in a byte.".Fmt(c.Value.Trim()));
                        return b;
                    }).ToArray();
                    break;

                default:
                    throw new InvalidOperationException("Please choose an input mode from the “Input semantics” menu.");
            }

            _inputIndex = 0;
            _settings = settings;
            if (!settings.MemoryAnnotations.ContainsKey(settings.LastMemoryAnnotationSet))
                settings.MemoryAnnotations[settings.LastMemoryAnnotationSet] = new Dictionary<Direction, Dictionary<PointAxial, string>>();
            _memory = new Memory(settings.MemoryAnnotations[settings.LastMemoryAnnotationSet]);
        }

 public static IEnumerator DelayInputModeSwitch(InputMode switchTo)
 {
     float elapsedTime = 0;
     while (elapsedTime <= GameConstants.DELAYED_INPUT_SWITCH_DURATION)
     {
         elapsedTime += Time.unscaledDeltaTime;
         yield return null;
     }
     mode = switchTo;
     DelayedSwitch = null;
 }

 /// <summary>
 ///     Constructs ad instance of the RawAppCommandInputReport class.
 /// </summary>
 /// <param name="inputSource">
 ///     The input source that provided this input.
 /// </param>
 /// <param name="mode">
 ///     The mode in which the input is being provided.
 /// </param>
 /// <param name="timestamp">
 ///     The time when the input occured.
 /// </param>
 /// <param name="appCommand">
 ///     The Application Command associated.
 /// </param>
 /// <param name="device">
 ///     The device that generated the app command.
 /// </param>
 /// <param name="inputType">the input device that generated the input event</param>
 internal RawAppCommandInputReport(
     PresentationSource  inputSource,
     InputMode           mode,
     int                 timestamp,
     int                 appCommand,
     InputType           device,
     InputType           inputType) : base(inputSource, inputType, mode, timestamp)
 {
     _appCommand = appCommand;
     _device = device;
 }

        protected InputReport(PresentationSource inputSource, InputType type, InputMode mode, int timestamp)
        {
            if (inputSource == null)
                throw new ArgumentNullException("inputSource");

            Validate_InputType( type );
            Validate_InputMode( mode );
            _inputSource= new SecurityCriticalData<PresentationSource>(inputSource);
            _type = type;
            _mode = mode;
            _timestamp = timestamp;
        }

    // Update is called once per frame
    void Update()
    {
        // None -> Hold
        // Hold -> Tap, or Drag
        // Tap, Drag -> None

        // Get data we will need
        // We only care about clicks if they are not over a UI element
        leftButtonDown = Input.GetMouseButton(0)
                       && !UnityEngine.EventSystems.EventSystem.current.IsPointerOverGameObject();
        Vector2 currentPosition = Input.mousePosition;

        switch (currentInputMode) {
        case InputMode.None:
            // If we are in the default mode, we can only enter Hold mode
            if (leftButtonDown) {
                currentInputMode = InputMode.Hold;
                lastPosition = currentPosition;
            }
            break;
        case InputMode.Hold:
            // If we are holding, we have to check position (transforming to Drag)
            // and releaseing the click (transforming to Tap)
            if (GetFastDistance(currentPosition, lastPosition) < 10 &&
                framesSinceLastClick < 5) {
                // Tap
                if (!leftButtonDown) {
                    currentInputMode = InputMode.Tap;
                    eventPosition = currentPosition;
                }
            }
            else {
                // Drag
                currentInputMode = InputMode.Drag;
                eventPosition = currentPosition;
            }
            break;
        case InputMode.Tap:
            currentInputMode = InputMode.None;
            break;
        case InputMode.Drag:
            if (leftButtonDown) {
                framesSinceLastClick++;
                lastPosition = eventPosition;
                eventPosition = currentPosition;
            }
            else {
                framesSinceLastClick = 0;
                currentInputMode = InputMode.None;
            }
            break;
        }
    }

        /// <summary> 
        ///     Constructs ad instance of the RawKeyboardInputReport class.
        /// </summary> 
        /// <param name="inputSource">
        ///     The input source that provided this input.
        /// </param>
        /// <param name="mode"> 
        ///     The mode in which the input is being provided.
        /// </param> 
        /// <param name="timestamp"> 
        ///     The time when the input occured.
        /// </param> 
        /// <param name="isDeadCharacter">
        ///     True if the char code is a dead char.
        /// </param>
        /// <param name="isSystemCharacter"> 
        ///     True if the char code is a system char.
        /// </param> 
        /// <param name="isControlCharacter"> 
        ///     True if the char code is a control char.
        /// </param> 
        /// <param name="characterCode">
        ///     The character code.
        /// </param>
        public RawTextInputReport( 
            PresentationSource inputSource,
            InputMode mode, 
            int timestamp, 
            bool isDeadCharacter,
            bool isSystemCharacter, 
            bool isControlCharacter,
            char characterCode) : base(inputSource, InputType.Text, mode, timestamp)
        {
            _isDeadCharacter = isDeadCharacter; 
            _isSystemCharacter = isSystemCharacter;
            _isControlCharacter = isControlCharacter; 
 
            _characterCode = characterCode;
        } 

        public RawUIStateInputReport(
            PresentationSource inputSource,
            InputMode mode,
            int timestamp,
            RawUIStateActions action,
            RawUIStateTargets targets) : base(inputSource, InputType.Keyboard, mode, timestamp)
        {
            if (!IsValidRawUIStateAction(action))
                throw new System.ComponentModel.InvalidEnumArgumentException("action", (int)action, typeof(RawUIStateActions));
            if (!IsValidRawUIStateTargets(targets))
                throw new System.ComponentModel.InvalidEnumArgumentException("targets", (int)targets, typeof(RawUIStateTargets));

            _action = action;
            _targets = targets;
        }

        public RawMouseInputReport(
            InputMode mode,
            int timestamp, 
            PresentationSource inputSource,
            RawMouseActions actions, 
            int x, 
            int y, 
            int wheel, 
            IntPtr extraInformation) : base(inputSource, InputType.Mouse, mode, timestamp)
        {
            if (!IsValidRawMouseActions(actions))
                throw new System.ComponentModel.InvalidEnumArgumentException("actions", (int)actions, typeof(RawMouseActions));

            /* we pass a null state from MouseDevice.PreProcessorInput, so null is valid value for state */
            _actions = actions;
            _x = x;
            _y = y;
            _wheel = wheel;
            _extraInformation = new SecurityCriticalData<IntPtr>(extraInformation);
        }

        public RawKeyboardInputReport(
            PresentationSource inputSource,
            InputMode mode,
            int timestamp, 
            RawKeyboardActions actions, 
            int scanCode, 
            bool isExtendedKey,
            bool isSystemKey,
            int virtualKey, 
            IntPtr extraInformation) : base(inputSource, InputType.Keyboard, mode, timestamp)
        {
            if (!IsValidRawKeyboardActions(actions))
                throw new System.ComponentModel.InvalidEnumArgumentException("actions", (int)actions, typeof(RawKeyboardActions));

            _actions = actions;
            _scanCode = scanCode;
            _isExtendedKey = isExtendedKey;
            _isSystemKey = isSystemKey;
            _virtualKey = virtualKey;
            _extraInformation = new SecurityCriticalData<IntPtr>(extraInformation);
        }

 public QuestionMutliOrSingelInputViewModel(object question, InputMode inputMode)
     : base(question, inputMode)
 {
 }