public static double GetValueScroll(string id, double initial, double step, MyKeys modifier = MyKeys.None, int roundDigits = 10, int notifyTime = 16)
        {
            if(!values.ContainsKey(id))
                values.Add(id, initial);

            var val = values[id];

            if(modifier != MyKeys.None && !MyAPIGateway.Input.IsKeyPress(modifier))
                return val;

            var scroll = MyAPIGateway.Input.DeltaMouseScrollWheelValue();

            if(scroll != 0)
            {
                val += (scroll > 0 ? step : -step);

                if(roundDigits > -1)
                    val = Math.Round(val, roundDigits);

                values[id] = val;
            }

            MyAPIGateway.Utilities.ShowNotification(id + "=" + val.ToString("#,###,###,##0.##########"), notifyTime);
            return val;
        }

        public ThrottledKeyStatus GetKeyStatus(MyKeys key)
        {
            if (!MyInput.Static.IsKeyPress(key))
                return ThrottledKeyStatus.UNPRESSED;

            var controller = GetKeyController(key);

            // If we find no controller, we cannot time so we assume the key is ready.
            if (controller == null)
                return ThrottledKeyStatus.PRESSED_AND_READY;

            // If the key was pressed during this update cycle, the key is deemed as instantly
            // ready, but it will be a longer delay before the next repeat is allowed.
            var wasPressedNow = MyInput.Static.IsNewKeyPressed(key);
            if (wasPressedNow)
            {
                controller.RequiredDelay = MyGuiConstants.TEXTBOX_INITIAL_THROTTLE_DELAY;
                controller.LastKeyPressTime = MyGuiManager.TotalTimeInMilliseconds;
                return ThrottledKeyStatus.PRESSED_AND_READY;
            }

            // If this is a continuous key press, we want to make sure we wait a minimum amount of time before allowing a repeat
            // of the action this key enables.
            if ((MyGuiManager.TotalTimeInMilliseconds - controller.LastKeyPressTime) > controller.RequiredDelay)
            {
                // Reset the required delay to the default for the next repeat.
                controller.RequiredDelay = MyGuiConstants.TEXTBOX_REPEAT_THROTTLE_DELAY;
                controller.LastKeyPressTime = MyGuiManager.TotalTimeInMilliseconds;
                return ThrottledKeyStatus.PRESSED_AND_READY;
            }

            // The key was pressed, but we're still waiting for the required delay.
            return ThrottledKeyStatus.PRESSED_AND_WAITING;
        }

        private MyKeyThrottleState GetKeyController(MyKeys key)
        {
            MyKeyThrottleState controller;
            if (m_keyTimeControllers.TryGetValue(key, out controller))
                return controller;

            controller = new MyKeyThrottleState();
            m_keyTimeControllers[key] = controller;
            return controller;
        }

        public void SetControl(MyGuiInputDeviceEnum device, MyKeys key)
        {
            Debug.Assert(device == MyGuiInputDeviceEnum.Keyboard ||
                         device == MyGuiInputDeviceEnum.KeyboardSecond);

            if (device == MyGuiInputDeviceEnum.Keyboard)
                m_keyboardKey = key;
            else if (device == MyGuiInputDeviceEnum.KeyboardSecond)
                m_KeyboardKey2 = key;
            else
                MyLog.Default.WriteLine("ERROR: Setting non-keyboard device to keyboard control.");
        }

 public MyControl(MyStringId controlId,
     MyStringId name,
     MyGuiControlTypeEnum controlType,
     MyMouseButtonsEnum? defaultControlMouse,
     MyKeys? defaultControlKey,
     MyStringId? helpText = null,
     MyKeys? defaultControlKey2 = null,
     MyStringId? description = null)
 {
     m_controlId = controlId;
     m_name = name;
     m_controlType = controlType;
     m_mouseButton = defaultControlMouse ?? MyMouseButtonsEnum.None;
     m_keyboardKey = defaultControlKey ?? MyKeys.None;
     m_KeyboardKey2 = defaultControlKey2 ?? MyKeys.None;
     m_data.Description = description;
 }

        /// <summary>
        /// Determines if the given key was pressed during this update cycle, but it also
        /// makes sure a minimum amount of time has passed before allowing a press.
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool IsNewPressAndThrottled(MyKeys key)
        {
            if (!MyInput.Static.IsNewKeyPressed(key))
                return false;

            var controller = GetKeyController(key);

            // If we find no controller, we cannot time so we assume the key is ready.
            if (controller == null)
                return true;

            // Make sure we wait a minimum amount of time before allowing a repeat of the action this key enables. This
            // version of the check overrides the currently configured required delay for the key on purpose.
            if ((MyGuiManager.TotalTimeInMilliseconds - controller.LastKeyPressTime) > MyGuiConstants.TEXTBOX_MOVEMENT_DELAY)
            {
                // Reset the required delay to the default for the next repeat.
                controller.LastKeyPressTime = MyGuiManager.TotalTimeInMilliseconds;
                return true;
            }

            // The key was pressed but was choked by the minimum time requirement.
            return false;
        }

 //  Return true if key was pressed in previous update and now it is not.
 bool ModAPI.IMyInput.IsNewKeyReleased(MyKeys key) { return IsNewKeyReleased(key); }

 //  Return true if new key pressed right now. Don't care if it was pressed in previous update too.
 bool ModAPI.IMyInput.IsKeyPress(MyKeys key) { return IsKeyPress(key); }

 //  Return true if key is used by some user control
 ModAPI.IMyControl ModAPI.IMyInput.GetControl(MyKeys key) { return GetControl(key); }

 //  Return true if key is valid for user controls
 bool ModAPI.IMyInput.IsKeyValid(MyKeys key) { return IsKeyValid(key); }

 bool IMyInput.IsNewKeyPressed(MyKeys key) { return false; }

 public bool IsKeyUp(MyKeys key)
 {
     return !IsKeyDown(key);
 }

 public bool IsKeyDown(MyKeys key)
 {
     return m_buffer.GetBit((byte)key);
 }

 public void SetKey(MyKeys key, bool value)
 {
     m_buffer.SetBit((byte)key, value);
 }

 public bool IsSkipCharacter(MyKeys character)
 {
     if (SkipCombinations != null)
         foreach (var skipCombination in SkipCombinations)
         {
             if (skipCombination.Alt == MyInput.Static.IsAnyAltKeyPressed() &&
                 skipCombination.Ctrl == MyInput.Static.IsAnyCtrlKeyPressed() &&
                 skipCombination.Shift == MyInput.Static.IsAnyShiftKeyPressed() &&
                 (skipCombination.Keys == null ||
                 skipCombination.Keys.Contains((MyKeys)character)))
             {
                 return true;
             }
         }
     return false;
 }

 public bool IsKeyDigit(MyKeys key)
 {
     Debug.Assert(false, "Not keyboard support!");
     return false;
     
 }

 //  Return true if key is used by some user control
 public MyControl GetControl(MyKeys key)
 {
     foreach (var item in m_gameControlsList.Values)
     {
         if (item.GetKeyboardControl() == key ||
             item.GetSecondKeyboardControl() == key) return item;
     }
     return null;
 }

 bool ModAPI.IMyInput.IsKeyDigit(MyKeys key) { return IsKeyDigit(key); }

 public string GetKeyName(MyKeys key)
 {
     return m_nameLookup.GetKeyName(key);
 }

 string ModAPI.IMyInput.GetKeyName(MyKeys key) { return GetKeyName(key); }