/// <summary>
        /// Try and get the KeyInput which corresponds to the given Key and modifiers
        /// TODO: really think about this method
        /// </summary>
        internal bool TryGetKeyInput(Key key, ModifierKeys modifierKeys, out KeyInput keyInput)
        {
            // First just check and see if there is a direct mapping
            var keyType = new KeyType(key, modifierKeys);
            if (_cache.TryGetValue(keyType, out keyInput))
            {
                return true;
            }

            // Next consider only the shift key part of the requested modifier.  We can
            // re-apply the original modifiers later
            keyType = new KeyType(key, modifierKeys & ModifierKeys.Shift);
            if (_cache.TryGetValue(keyType, out keyInput))
            {
                // Reapply the modifiers
                keyInput = KeyInputUtil.ChangeKeyModifiers(keyInput, ConvertToKeyModifiers(modifierKeys));
                return true;
            }

            // Last consider it without any modifiers and reapply
            keyType = new KeyType(key, ModifierKeys.None);
            if (_cache.TryGetValue(keyType, out keyInput))
            {
                // Reapply the modifiers
                keyInput = KeyInputUtil.ChangeKeyModifiers(keyInput, ConvertToKeyModifiers(modifierKeys));
                return true;
            }

            return false;
        }

    public KeySequence(string name, KeyType[] keys, Element prim, Element sec) {
    	this.name = name;
        _keys = keys;
        Primary = prim;
        Secondary = sec;

    }

 public EntityKey(string value, KeyType type)
 {
     if (value == null) throw new ArgumentNullException("key");
     _value = value;
     _hashedValue = EntityBuilder.Fnv1Hash(_value);
     _type = type;
 }

 public RainbowFolder(KeyType type, string key, Texture2D smallIcon, Texture2D largeIcon)
 {
     Type = type;
     Key = key;
     SmallIcon = smallIcon;
     LargeIcon = largeIcon;
 }

 public Key(double time, double value, KeyType inFunction, BaseTweenType baseTweenType)
 {
     Time = time;
     Value = value;
     InFunction = inFunction;
     BaseTweenType = baseTweenType;
 }

 /// <inheritdoc/>>
 public bool OnKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey)
 {
     bool result = false;
     Debug.WriteLine(String.Format("OnKeyEvent: KeyType: {0} 0x{1:X} Modifiers: {2}", type, windowsKeyCode, modifiers));
     // TODO: Handle MessageNeeded cases here somehow.
     return result;
 }

 public KeyEventArgs(int scanCode, KeyType type, int value, int timeStamp)
 {
     ScanCode = scanCode;
     Type = type;
     Value = value;
     TimeStamp = timeStamp;
 }

		public static byte[] Retrieve (KeyType kt)
		{
			string key = null;
			
			switch (kt) {
				case KeyType.Validation:
					key = keyValidation;
					break;

				case KeyType.Encryption:
					key = keyEncryption;
					break;

				default:
					throw new ArgumentException ("Unknown key type.");
			}

			if (key == null)
				return null;
			
			object o = null;

			try {
				RegistryKey v = OpenRegistryKey (key, false);
				o = v.GetValue ("AutoGenKey", null);
			} catch (Exception) {
				return null;
			}

			if (o == null || o.GetType () != typeof (byte[]))
				return null;
			return (byte[]) o;
		}

	public KeyActionConfig(KeyType type, int order, Action down, Action up)
	{
		Category = type;
        Order = order;
		KeyDownAction = down;
		KeyUpAction = up;
	}

    public void AddIconByKeyType(KeyType keyType)
    {
        GameObject prefab = null;

        switch (keyType)
        {
            case KeyType.A:
                prefab = plantIcon;
                break;
            case KeyType.B:
                prefab = boneIcon;
                break;
            case KeyType.C:
                prefab = mineralIcon;
                break;
            case KeyType.D:
                prefab = fluidIcon;
                break;
        }

        if (prefab != null)
        {
            // set prefab position
            prefab.transform.position = new Vector3
            (
                transform.position.x + (_icons.Count - 1),
                transform.position.y,
                transform.position.z + (_icons.Count - 1)
            );
            
            GameObject newIcon = Instantiate(prefab);
            _icons.Add(newIcon);
        }
    }

 public ArrowComponent(GameObject parent)
     : base(parent)
 {
     arrowKey = ArrowType.None;
     keyTimer = 0;
     keyPressed = KeyType.None;
 }

 public ProtocolKeyAttribute(string name, string defaultValue, KeyUsagePhase phase, KeySender sender, KeyType type)
 {
     _name = name;
     _default = defaultValue;
     _phase = phase;
     _sender = sender;
     _type = type;
 }

		public KeyInfo( Key key )
		{
			m_KeyVal = key.KeyValue;
			m_Description = key.Description;
			m_MaxRange = key.MaxRange;
			m_Link = key.Link;
			m_Type = (KeyType)key.ItemID;
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="Key"/> class.
 /// </summary>
 public Key(char key)
 {
     keyType = KeyType.RegularKey;
     character = key;
     control = false;
     alt = false;
     shift = char.IsUpper(key);
 }

 static int GetKey(KeyType keyType, ushort length, byte dec)
 {
     var result = 0;
     result |= (int)keyType << 24;
     result |= (int)dec << 16;
     result |= length;
     return result;
 }

        public bool OnPreKeyEvent(IWebBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey, bool isKeyboardShortcut)
        {
            bool block = false;
            if (KeyCommand != null)
                block = KeyCommand(this, windowsKeyCode);

            return block;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Key"/> class.
 /// </summary>
 public Key()
 {
     keyType = KeyType.NoKey;
     character = (char)0x00;
     control = false;
     alt = false;
     shift = false;
 }

 public bool OnPreKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode,
     CefEventFlags modifiers, bool isSystemKey, ref bool isKeyboardShortcut)
 {
     if (windowsKeyCode == (int)Keys.F12)
     {
         Program.Form.ChromiumBrowser.ShowDevTools();
     }
     return false;
 }

        public Key( KeyType type, uint LockVal, Item link )
            : base((int)type)
        {
            Weight = 1.0;

            m_MaxRange = 3;
            m_KeyVal = LockVal;
            m_Link = link;
        }

 private static void waiting(KeyType type)
 {
     keySemaphore = KeyType.NOTHING;
     do
     {
             Thread.Sleep(200);
     } while(keySemaphore != type);
     keySemaphore = KeyType.NOTHING;
 }