public DirectInputGamePad(DirectInput directInput, GamePadKey key) : base(key)
 {
     this.key = key;
     this.directInput = directInput;
     this.instance = new Joystick(directInput, key.Guid);
     joystickState = new JoystickState();
 }

 // TODO: allow user to configure the action based on value (vibrato, pitch shift, etc.)
 /// <summary>
 /// Emulates behaviour like that of <see cref="JoystickState.GetButtons()"/>.
 /// </summary>
 /// 
 /// <param name="state">
 /// The <see cref="JoystickState"/> instance to query.
 /// </param>
 /// 
 /// <returns>
 /// An array of integers representing the values of the respective axes.
 /// </returns>
 /// 
 /// <remarks>
 /// The irony here is that the value are probably read from an array in the first place.
 /// </remarks>
 public static int[] GetValues(JoystickState state)
 {
     int[] result = new int[] {
         state.ARx,
         state.ARy,
         state.ARz,
         state.AX,
         state.AY,
         state.AZ,
         state.FRx,
         state.FRy,
         state.FRz,
         state.FX,
         state.FY,
         state.FZ,
         state.Rx,
         state.Ry,
         state.Rz,
         state.VRx,
         state.VRy,
         state.VRz,
         state.VX,
         state.VY,
         state.VZ,
         state.X,
         state.Y,
         state.Z,
     };
     return result;
 }

        public bool[][] buttons = new bool[3][]; //2D-array, 1.dim = joystick, 2.dim = button
        

        public JoystickHandler()
        {
            getSticks();
            sticks = getSticks();
            state = new JoystickState();
            joystickDialog = new JoystickConfig();
        }

        public static DirectXControllerFunction Create(DirectXControllerInterface controllerInterface, Guid objectType, int objectNumber, JoystickState initialState)
        {
            DirectXControllerFunction function = null;

            if (objectType == ObjectGuid.Button)
                function = new DirectXControllerButton(controllerInterface, objectNumber, initialState);
            else if (objectType == ObjectGuid.Slider)
                function = new DirectXControllerAxis(controllerInterface, DirectXControllerAxis.AxisType.Slider, objectNumber, initialState);
            else if (objectType == ObjectGuid.XAxis)
                function = new DirectXControllerAxis(controllerInterface, DirectXControllerAxis.AxisType.X, objectNumber, initialState);
            else if (objectType == ObjectGuid.YAxis)
                function = new DirectXControllerAxis(controllerInterface, DirectXControllerAxis.AxisType.Y, objectNumber, initialState);
            else if (objectType == ObjectGuid.ZAxis)
                function = new DirectXControllerAxis(controllerInterface, DirectXControllerAxis.AxisType.Z, objectNumber, initialState);
            else if (objectType == ObjectGuid.RxAxis)
                function = new DirectXControllerAxis(controllerInterface, DirectXControllerAxis.AxisType.Rx, objectNumber, initialState);
            else if (objectType == ObjectGuid.RyAxis)
                function = new DirectXControllerAxis(controllerInterface, DirectXControllerAxis.AxisType.Ry, objectNumber, initialState);
            else if (objectType == ObjectGuid.RzAxis)
                function = new DirectXControllerAxis(controllerInterface, DirectXControllerAxis.AxisType.Rz, objectNumber, initialState);
            else if (objectType == ObjectGuid.PovController)
                function = new DirectXControllerPOVHat(controllerInterface, objectNumber, initialState);

            return function;
        }

 public void UpdateFrom(Joystick device, out JoystickState state)
 {
     if (!AppHelper.IsSameDevice(device, deviceInstanceGuid))
     {
         ShowDeviceInfo(device);
         deviceInstanceGuid = Guid.Empty;
         if (device != null)
         {
             deviceInstanceGuid = device.Information.InstanceGuid;
             isWheel = device.Information.Type == SharpDX.DirectInput.DeviceType.Driving;
         }
     }
     state = null;
     if (device != null)
     {
         try
         {
             device.Acquire();
             state = device.GetCurrentState();
         }
         catch (Exception ex)
         {
             var error = ex;
         }
     }
     ShowDirectInputState(state);
 }

        public JoystickState GetState(int index)
        {
            XInputState xstate;
            XInputErrorCode error = xinput.GetState((XInputUserIndex)index, out xstate);

            JoystickState state = new JoystickState();
            if (error == XInputErrorCode.Success)
            {
                state.SetIsConnected(true);

                state.SetAxis(JoystickAxis.Axis0, (short)xstate.GamePad.ThumbLX);
                state.SetAxis(JoystickAxis.Axis1, (short)Math.Min(short.MaxValue, -xstate.GamePad.ThumbLY));
                state.SetAxis(JoystickAxis.Axis2, (short)Common.HidHelper.ScaleValue(xstate.GamePad.LeftTrigger, 0, byte.MaxValue, short.MinValue, short.MaxValue));
                state.SetAxis(JoystickAxis.Axis3, (short)xstate.GamePad.ThumbRX);
                state.SetAxis(JoystickAxis.Axis4, (short)Math.Min(short.MaxValue, -xstate.GamePad.ThumbRY));
                state.SetAxis(JoystickAxis.Axis5, (short)Common.HidHelper.ScaleValue(xstate.GamePad.RightTrigger, 0, byte.MaxValue, short.MinValue, short.MaxValue));

                state.SetButton(JoystickButton.Button0, (xstate.GamePad.Buttons & XInputButtons.A) != 0);
                state.SetButton(JoystickButton.Button1, (xstate.GamePad.Buttons & XInputButtons.B) != 0);
                state.SetButton(JoystickButton.Button2, (xstate.GamePad.Buttons & XInputButtons.X) != 0);
                state.SetButton(JoystickButton.Button3, (xstate.GamePad.Buttons & XInputButtons.Y) != 0);
                state.SetButton(JoystickButton.Button4, (xstate.GamePad.Buttons & XInputButtons.LeftShoulder) != 0);
                state.SetButton(JoystickButton.Button5, (xstate.GamePad.Buttons & XInputButtons.RightShoulder) != 0);
                state.SetButton(JoystickButton.Button6, (xstate.GamePad.Buttons & XInputButtons.Back) != 0);
                state.SetButton(JoystickButton.Button7, (xstate.GamePad.Buttons & XInputButtons.Start) != 0);
                state.SetButton(JoystickButton.Button8, (xstate.GamePad.Buttons & XInputButtons.LeftThumb) != 0);
                state.SetButton(JoystickButton.Button9, (xstate.GamePad.Buttons & XInputButtons.RightThumb) != 0);
                state.SetButton(JoystickButton.Button10, (xstate.GamePad.Buttons & XInputButtons.Guide) != 0);

                state.SetHat(JoystickHat.Hat0, new JoystickHatState(TranslateHat(xstate.GamePad.Buttons)));
            }

            return state;
        }

        public static unsafe void Update(int index, int[] analogData, byte[] digitalData)
        {
            //Create the structure
              var state = new JoystickState();
              state.Signature = (uint)0x53544143;
              state.NumAnalog = (char)63;
              state.NumDigital = (char)128;
              state.Analog = new int[state.NumAnalog];
              state.Digital = new char[state.NumDigital];

              //Fill it with our data
              if (analogData != null)
            Array.Copy(analogData, 0, state.Analog, 0, Math.Min(analogData.Length, state.Analog.Length));
              if (digitalData != null)
            Array.Copy(digitalData, 0, state.Digital, 0, Math.Min(digitalData.Length, state.Digital.Length));

              //Send the data
              uint bytesReturned = 0;
              NativeOverlapped overlapped = new NativeOverlapped();
              var h = _GetHandle(index);
              bool ret = DeviceIoControl(h, 0x00220000,
             state, (uint)Marshal.SizeOf(state),
             IntPtr.Zero, 0, ref bytesReturned, ref overlapped);

              if (!ret)
              {
            //TODO: Do something with this?
            int lastError = Marshal.GetLastWin32Error();

            //Invalidate the handle
            _CloseHandle(h);
            _handles[index] = null;
              }
        }

 internal static JoystickState NormalizeInput(short X, short Y, short inputDeadZone, short joystickRange)
 {
     //From http://msdn.microsoft.com/en-us/library/windows/desktop/ee417001(v=vs.85).aspx
     JoystickState result = new JoystickState();
     //determine how far the controller is pushed
     result.Magnitude = (float)Math.Sqrt(X * X + Y * Y);
     //determine the direction the controller is pushed
     result.NormalizedX = X / result.Magnitude;
     result.NormalizedY = Y / result.Magnitude;
     result.NormalizedMagnitude = 0;
     //check if the controller is outside a circular dead zone
     if (result.Magnitude > inputDeadZone)
     {
         //clip the magnitude at its expected maximum value
         if (result.Magnitude > joystickRange)
             result.Magnitude = joystickRange;
         //adjust magnitude relative to the end of the dead zone
         result.Magnitude -= inputDeadZone;
         //optionally normalize the magnitude with respect to its expected range
         //giving a magnitude value of 0.0 to 1.0
         result.NormalizedMagnitude = result.Magnitude / (joystickRange - inputDeadZone);
     }
     else //if the controller is in the deadzone zero out the magnitude
     {
         result.Magnitude = 0;
         result.NormalizedMagnitude = 0;
     }
     return result;
 }

        public void Poll()
        {
            this.device.Poll();
            this.state = this.device.CurrentJoystickState;
            byte[] newButtons = this.state.GetButtons();

            if (this.buttons == null)
            {
                this.buttons = newButtons;
                this.HasButtonStateChanged = true;
                return;
            }

            this.IsButtonPressed = false;
            this.HasButtonStateChanged = false;
            for (int i = 0; i < newButtons.Length; i++)
            {
                if (newButtons[i] != this.buttons[i])
                {
                    this.HasButtonStateChanged = true;
                }

                if (newButtons[i] > 0)
                {
                    this.IsButtonPressed = true;
                }
            }

            if (this.HasButtonStateChanged)
            {
                this.buttons = newButtons;
            }
        }

        //Function of initialize device
        public static void InitDevices()
        {
            //create joystick device.
            foreach (DeviceInstance di in Manager.GetDevices(
                DeviceClass.GameControl,
                EnumDevicesFlags.AttachedOnly))
            {
                joystick = new Device(di.InstanceGuid);
                break;
            }
            if (joystick == null)
            {
                //Throw exception if joystick not found.
            }
            //Set joystick axis ranges.
            else {
                foreach (DeviceObjectInstance doi in joystick.Objects)
                {
                    if ((doi.ObjectId & (int)DeviceObjectTypeFlags.Axis) != 0)
                    {
                        joystick.Properties.SetRange(
                            ParameterHow.ById,
                            doi.ObjectId,
                            new InputRange(-5000, 5000));
                    }

                }
                joystick.Properties.AxisModeAbsolute = true;

                joystick.SetCooperativeLevel(null,CooperativeLevelFlags.NonExclusive | CooperativeLevelFlags.Background);
                //Acquire devices for capturing.
                joystick.Acquire();
                state = joystick.CurrentJoystickState;
            }
        }

        public DirectXControllerAxis(DirectXControllerInterface controllerInterface, AxisType type, int axisNumber, JoystickState initialState)
        {
            _axisType = type;
            _axisNumber = axisNumber;

            _value = new HeliosValue(controllerInterface, new BindingValue(GetValue(initialState)), "", Name, "Current value for " + Name + ".", "(0 - 65536)", BindingValueUnits.Numeric);
            _triggers.Add(_value);
        }

 /// <summary>Retrieves the current value of the axis</summary>
 /// <param name="gamePadState">Game pad state that will receive the value</param>
 /// <param name="joystickState">State from which the axis is retrieved</param>
 public void Convert(
   FlatGamePadState gamePadState, ref JoystickState joystickState
 ) {
   if (joystickState.X < base.Center) {
     gamePadState.LeftThumbStick.X = (float)(base.Center - joystickState.X) / base.Min;
   } else {
     gamePadState.LeftThumbStick.X = (float)(joystickState.X - base.Center) / base.Max;
   }
 }

        public override void Update(GameTime gameTime)
        {
            base.Update(gameTime);

            _joyState = Application.InputManager.GetJoystickState(Index);

            // Mapping
            // TODO Joypad mapping

            // End
            _previousJoystate = _joyState;
        }

        public double GetValue(JoystickState joystickState, int povIndex)
        {
            // Position is quantized degrees from North quantized to the four cardinal directions.
            int position = joystickState.GetPointOfViewControllers()[povIndex];
            foreach(Range range in _directionRanges) {
                if(range.Contains(position)) {
                    return range.Value / 100d;
                }
            }

            return -1;
        }

      /// <summary>Retrieves the current value of the axis</summary>
      /// <param name="state">Joystick state the axis is taken from</param>
      /// <returns>The value of the axis in the joystick state</returns>
      public float GetValue(ref JoystickState state)
      {
        int raw = Read(ref state);

        if (raw < this.center)
        {
          return (float) (this.center - raw)/this.min;
        }
        else
        {
          return (float) (raw - this.center)/this.max;
        }
      }

        public DirectXControllerButton(DirectXControllerInterface controllerInterface, int buttonNumber, JoystickState initialState)
        {
            _buttonNumber = buttonNumber;
            _name = "Button " + (_buttonNumber + 1);
            _value = new HeliosValue(controllerInterface, new BindingValue(GetValue(initialState)), "", _name, "Current state for " + _name + ".", "True if pressed, false other wise.", BindingValueUnits.Boolean);

            _press = new HeliosTrigger(controllerInterface, "", _name, "pressed", "Fires when " + _name + " is pressed.", "Always returns true.", BindingValueUnits.Boolean);
            _release = new HeliosTrigger(controllerInterface, "", _name, "released", "Fires when " + _name + " is released.", "Always returns false.", BindingValueUnits.Boolean);

            _triggers.Add(_press);
            _triggers.Add(_release);

            _lastPollValue = GetValue(initialState);
        }

        public void Poll(Action<JoystickState> f)
        {
            if (joystick.Acquire().IsFailure)
                return;

            if (joystick.Poll().IsFailure)
                return;

            joyState = joystick.GetCurrentState();
            if (Result.Last.IsFailure)
                return;

            // Joystick is all good, call the function
            f(joyState);
        }

        public override void Initialize()
        {
            buttonDown = -1;
            joystickIsReady = false;

            // Make sure that DirectInput has been initialized
            DirectInput dinput = new DirectInput();
            state = new JoystickState();

            // search for devices
            foreach (DeviceInstance device in dinput.GetDevices(DeviceClass.GameController, DeviceEnumerationFlags.AttachedOnly))
            {
                // create the device
                try
                {
                    joystick = new Joystick(dinput, device.InstanceGuid);
                    joystick.SetCooperativeLevel(Core.Settings.RenderForm.Handle,
                        CooperativeLevel.Exclusive | CooperativeLevel.Foreground);
                    break;
                }
                catch (DirectInputException)
                {
                }
            }

            if (joystick != null)
            {
                foreach (DeviceObjectInstance deviceObject in joystick.GetObjects())
                {
                    if ((deviceObject.ObjectType & ObjectDeviceType.Axis) != 0)
                        joystick.GetObjectPropertiesById((int)deviceObject.ObjectType).SetRange(-1000, 1000);
                }
            }
            else
            {
                return;
            }

            // acquire the device
            joystick.Acquire();

            timer = new Timer();
            timer.Interval = 1000 / 10;
            timer.Tick += new EventHandler(timer_Tick);
            timer.Start();
        }

        protected override void ProcessController()
        {
            ControllerState newState = new ControllerState();
            JoystickState joyState = new JoystickState();

            if (this.padsList == null || !this.padsList.Any())
            {
                this.padsList = this.GetGamePads();
                if (!this.padsList.Any()) return;
            }

            if (this.device == null)
            {
                this.device = this.padsList[0];
            }

            if (this.pad == null)
            {
                this.Acquire();
            }

            if (this.pad == null || this.pad.Poll().IsFailure || this.pad.GetCurrentState(ref joyState).IsFailure)
            {
                newState.Active = false;
            }
            else
            {
                //var objs = pad.GetObjects();
                newState.Active = true;
                newState.X = (joyState.X / 5000d);
                newState.Y = (joyState.Y / 5000d);
                newState.Buttons = joyState.GetButtons();
            }

            if (!newState.Equals(this.State))
            {

                this.State = newState;

                if (this.OnUpdate != null)
                {
                    this.OnUpdate.Invoke(this.State);
                }
            }
        }

        public void PollChanges(iGameClient GameCli)
        {
            //polls changes in this controller from the previous poll and raises
            //appropriate events in iGameClient depending on the differences.
            if (!haspolled)
            {
                haspolled=true;
                ourdevice.Poll();
                laststate = ourdevice.CurrentJoystickState;
                return;

            }
            laststate = ourdevice.CurrentJoystickState;
            ourdevice.Poll();

            byte[] prevbuttons = laststate.GetButtons();
            byte[] currbuttons = ourdevice.CurrentJoystickState.GetButtons();
        }