Inheritance: MonoBehaviour
コード例 #1
0
ファイル: Program.cs プロジェクト: evilz/isograd-tosa
        static void Main(string[] args)
        {
            var input = Console.In;
            //var input = new StringReader("6\nhome office\nhome garage\nhome parents_home\noffice lab\noffice library\nlibrary main_entrance");

            var count = int.Parse(input.ReadLine());

            var many = Enumerable.Range(0, count)
                .Select(_ =>
                    input.ReadLine()
                        .Split(' ')

                        .ToArray())
                        .ToArray();

            var dic = new Dictionary<string,key>();

            foreach (var key in many)
            {
                dic[key[0]] = new key(key[0]);
                dic[key[1]] = new key(key[1]);
            }

            foreach (var key in many)
            {
                var master = dic[key[0]];
                var slave = dic[key[1]];

                master.Children.Add(slave);
            }

            var master2 = dic.Values.OrderByDescending(key => key.Level).First();
            Console.WriteLine(master2.Level);
        }
コード例 #2
0
ファイル: Extensions.cs プロジェクト: hoki/HokiMacro
 public static void Register(this IDictionary<key, IList<Action<KeyArgs>>> dictionary, key key, Action<KeyArgs> action)
 {
     if (!dictionary.ContainsKey(key))
     {
         dictionary.Add(key, new List<Action<KeyArgs>>());
     }
     dictionary[key].Add(action);
 }
コード例 #3
0
ファイル: NoteShow.cs プロジェクト: Shad0wKing92/MusicTheory
	// Use this for initialization
	void Start () {
		gameObject.GetComponent<Renderer>().enabled = false;
		GetComponent<Renderer>().material.color = Color.blue;
		if(keyName == "MiddleC"){
			currentKey = key.MiddleC;
		}
		if(keyName == "CSharp"){
			currentKey = key.CSharp;
		}
		if(keyName == "D"){
			currentKey = key.D;
		}
		if(keyName == "DSharp"){
			currentKey = key.DSharp;
		}
		if(keyName == "E"){
			currentKey = key.E;
		}
		if(keyName == "F"){
			currentKey = key.F;
		}
		if (keyName == "FSharp") {
			currentKey = key.FSharp;
		}
		if(keyName == "G"){
			currentKey = key.G;
		}
		if (keyName == "GSharp") {
			currentKey = key.GSharp;
		}
		if(keyName == "A"){
			currentKey = key.A;
		}
		if (keyName == "ASharp") {
			currentKey = key.ASharp;
		}
		if(keyName == "B"){
			currentKey = key.B;
		}
		if(keyName == "HighC"){
			currentKey = key.HighC;
		}
		if (keyName == "HighCSharp") {
			currentKey = key.HighCSharp;
		}
		if(keyName == "HighD"){
			currentKey = key.HighD;
		}
		if (keyName == "HighDSharp") {
			currentKey = key.HighDSharp;
		}
		if(keyName == "HighE"){
			currentKey = key.HighE;
		}
		if(keyName == "HighF"){
			currentKey = key.HighF;
		}
	}
コード例 #4
0
ファイル: Controls.cs プロジェクト: evan-erdos/pathways
 static void AddInput(key k, string s)
 {
     switch (s) {
         case "menu": menu.f += k.f; break;
         case "term": term.f += k.f; break;
         case "invt": invt.f += k.f; break;
         case "lamp": lamp.f += k.f; break;
         case "fire": fire.f += k.f; break;
         case "jump": jump.f += k.f; break;
         case "duck": duck.f += k.f; break;
         case "dash": dash.f += k.f; break;
     }
 }
コード例 #5
0
 private key GenerateCollectionKey(IForeignKeyColumnInfo[] kdef)
 {
     key key;
     key = new key();
     if (kdef.Length == 1)
     {
         key.column1 = kdef[0].ForeignKeyColumnName;
     }
     else
     {
         key.column = kdef.Select(q => new column() { name = q.ForeignKeyColumnName }).ToArray();
     }
     return key;
 }
コード例 #6
0
ファイル: Controls.cs プロジェクト: evan-erdos/PathwaysEngine
 public Controls() { // why the how does it
     menu    = new key((n)=>menu.input=n);
     term    = new key((n)=>term.input=n);
     invt    = new key((n)=>invt.input=n);
     fire    = new key((n)=>fire.input=n);
     lamp    = new key((n)=>lamp.input=n);
     jump    = new key((n)=>jump.input=n);
     dash    = new key((n)=>dash.input=n);
     duck    = new key((n)=>duck.input=n);
     accept  = new key((n)=>accept.input=n);
     mouseX  = new axis((n)=>mouseX.input=n);
     mouseY  = new axis((n)=>mouseY.input=n);
     axisX   = new axis((n)=>axisX.input=n);
     axisY   = new axis((n)=>axisY.input=n);
     //roll  = new axis((n)=>roll.input=n);
 } // there is no reason for this how does it even
コード例 #7
0
ファイル: Controls.cs プロジェクト: evan-erdos/pathways
 public Controls()
 {
     // why the how does it
     menu 	= new key((n)=>menu.input=n);
     term 	= new key((n)=>term.input=n);
     invt 	= new key((n)=>invt.input=n);
     fire  	= new key((n)=>fire.input=n);
     lamp 	= new key((n)=>lamp.input=n);
     jump 	= new key((n)=>jump.input=n);
     dash 	= new key((n)=>dash.input=n);
     duck 	= new key((n)=>duck.input=n);
     mouseX 	= new axis((n)=>mouseX.input=n);
     mouseY 	= new axis((n)=>mouseY.input=n);
     axisX 	= new axis((n)=>axisX.input=n);
     axisY 	= new axis((n)=>axisY.input=n);
     roll 	= new axis((n)=>roll.input=n);
 }
コード例 #8
0
 if (string.IsNullOrEmpty(key))
 {
     throw new InvalidOperationException(Resources.Error_EmptyKey);
コード例 #9
0
 ValidateKeyValue(key, value);
コード例 #10
0
ファイル: Settings.cs プロジェクト: rajeshwarn/Thingy
 set => Set(key, value);
コード例 #11
0
 if (!Validate(key, value))
 {
     throw new InvalidOperationException($"Invalid value {value} for key '{key}'");
コード例 #12
0
ファイル: Extensions.cs プロジェクト: MiloszKrajewski/TooMany
 foreach (var(key, value) in other)
コード例 #13
0
 SetValueImpl(key, value);
コード例 #14
0
 set => UpdateWithNotification(key, value);
コード例 #15
0
ファイル: IvyConfig.cs プロジェクト: 0xF6/IvyVM
 private set => this.set(key, value);
コード例 #16
0
ファイル: Collection.cs プロジェクト: isaveu/Yggdrasil
 set => this.AddOrReplace(key, value);
コード例 #17
0
ファイル: jhl.Utility.cs プロジェクト: ssg100/ninjaindicators
			public bool Equals(ref key k)
			{
				return period == k.period
					&& input == k.input;
			}			
コード例 #18
0
foreach (var (key, value) in HtmlAttributes)
コード例 #19
0
 return this.Get(key);
コード例 #20
0
 SetPropertyNoCheck(key, value);
コード例 #21
0
 set => Put(key, value);
コード例 #22
0
        private void ProcessManyToOneReference(
            Entity entity,
            DirectedReference directedReference,
            Action <object> addItem,
            string cascade,
            string collectionCascade,
            string lazy,
            string orderByClause,
            bool inverse)
        {
            if (directedReference.FromEndEnabled == false)
            {
                return;
            }

            ITable referenceMappedTable = directedReference.Reference.MappedTable();
            DirectedRelationship directedRelationship = null;

            if (referenceMappedTable == null)
            {
                directedRelationship = GetDirectedMappedRelationship(entity, directedReference.Reference);
            }

            if (directedReference.FromEndCardinality == Cardinality.One)
            {
                fetchMode fetchMode;
                bool      insert;
                bool      update;

                if (directedReference.Entity1IsFromEnd)
                {
                    fetchMode = (fetchMode)Enum.Parse(typeof(fetchMode), directedReference.Reference.GetReferenceEnd1FetchMode().ToString(), true);
                    insert    = directedReference.Reference.GetReferenceEnd1Insert();
                    update    = directedReference.Reference.GetReferenceEnd1Update();
                }
                else
                {
                    fetchMode = (fetchMode)Enum.Parse(typeof(fetchMode), directedReference.Reference.GetReferenceEnd2FetchMode().ToString(), true);
                    insert    = directedReference.Reference.GetReferenceEnd2Insert();
                    update    = directedReference.Reference.GetReferenceEnd2Update();
                }
                manytoone manyToOneNode;

                if (referenceMappedTable == null)
                {
                    manyToOneNode = CreateManyToOneNode(directedReference, directedRelationship, cascade);
                }
                else
                {
                    manyToOneNode = CreateManyToOneNode(directedReference, referenceMappedTable);
                }

                manyToOneNode.fetch          = fetchMode;
                manyToOneNode.fetchSpecified = true;
                manyToOneNode.insert         = insert;
                manyToOneNode.update         = update;

                addItem(manyToOneNode);
            }
            else
            {
                key keyNode = new key();

                if (referenceMappedTable == null &&
                    directedRelationship.ToKey.Columns.Count > 1)
                {
                    foreach (var columnNode in GetColumnNodes(directedRelationship.ToKey.Columns))
                    {
                        keyNode.AddColumn(columnNode);
                    }
                }
                else if (referenceMappedTable != null)
                {
                    ITable toPrimaryMappedTable  = EntityMapper.GetPrimaryTable(directedReference.ToEntity);
                    var    toColumnsInPrimaryKey = referenceMappedTable.Relationships.First(t => t.PrimaryTable == toPrimaryMappedTable || t.ForeignTable == toPrimaryMappedTable).ForeignKey.Columns;

                    foreach (var columnNode in GetColumnNodes(toColumnsInPrimaryKey))
                    {
                        keyNode.AddColumn(columnNode);
                    }
                }
                else
                {
                    keyNode.column1 = directedRelationship.ToKey.Columns[0].Name.BackTick();
                }

                onetomany oneToManyNode = new onetomany();
                oneToManyNode.@class = directedReference.ToEntity.Name;

                collectionFetchMode collFetchMode;

                if (directedReference.Entity1IsFromEnd)
                {
                    collFetchMode = (collectionFetchMode)Enum.Parse(typeof(collectionFetchMode), directedReference.Reference.GetReferenceEnd1CollectionFetchMode().ToString(), true);
                }
                else
                {
                    collFetchMode = (collectionFetchMode)Enum.Parse(typeof(collectionFetchMode), directedReference.Reference.GetReferenceEnd2CollectionFetchMode().ToString(), true);
                }

                AssociationType type = NHCollections.GetAssociationType(directedReference);

                switch (type)
                {
                case AssociationType.None:
                    Log.WarnFormat("No association type was set on reference {0} for the end {1}. This is usually an error.", directedReference.Reference.Name, directedReference.Entity1IsFromEnd ? "1" : "2");
                    return;

                case AssociationType.Set:
                    var set = CreateSetNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
                    set.Item = oneToManyNode;

                    if (orderByClause.Length > 0)
                    {
                        set.orderby = orderByClause;
                    }

                    addItem(set);
                    break;

                case AssociationType.Map:
                    var mapNode = CreateMapNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
                    mapNode.Item = new index
                    {
                        column1 = NHCollections.GetIndexColumnName(directedReference),
                        type    = NHCollections.GetIndexColumnTypeName(directedReference, EntityMapper.GetPrimaryTable(directedReference.ToEntity))
                    };
                    mapNode.Item1 = oneToManyNode;

                    if (orderByClause.Length > 0)
                    {
                        mapNode.orderby = orderByClause;
                    }

                    addItem(mapNode);
                    break;

                case AssociationType.Bag:
                    var bag = CreateBagNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
                    bag.Item = oneToManyNode;

                    if (orderByClause.Length > 0)
                    {
                        bag.orderby = orderByClause;
                    }

                    addItem(bag);
                    break;

                case AssociationType.List:
                    list listNode = CreateListNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
                    listNode.Item = new index {
                        column1 = NHCollections.GetIndexColumnName(directedReference)
                    };
                    listNode.Item1 = oneToManyNode;

                    if (orderByClause.Length > 0)
                    {
                        listNode.orderby = orderByClause;
                    }

                    addItem(listNode);
                    break;

                case AssociationType.IDBag:
                    idbag idbagNode = CreateIdBagNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
                    idbagNode.collectionid = new collectionid
                    {
                        column1   = NHCollections.GetIndexColumnName(directedReference),
                        generator = new generator {
                            @class = "sequence"
                        },
                        type = NHCollections.GetIndexColumnTypeName(directedReference, EntityMapper.GetPrimaryTable(directedReference.ToEntity))
                    };

                    addItem(idbagNode);
                    break;

                default:
                    throw new ArgumentOutOfRangeException("AssociationType not handled yet: " + type.ToString());
                }
            }
        }
コード例 #23
0
        private void ProcessManyToManyReference(
            Entity entity,
            DirectedReference directedReference,
            Action <object> addItem,
            Dictionary <ITable, int> manyToManySameTableProcessingCounts,
            string collectionCascade,
            string lazy,
            string orderByClause,
            bool inverse)
        {
            if (directedReference.FromEndEnabled == false)
            {
                return;
            }

            ITable referenceMappedTable = directedReference.Reference.MappedTable();

            ITable      fromPrimaryMappedTable = EntityMapper.GetPrimaryTable(entity);
            ITable      toPrimaryMappedTable   = EntityMapper.GetPrimaryTable(directedReference.ToEntity);
            Cardinality cardinalityPrimary;
            Cardinality cardinalityForeign;
            IKey        mainKey;
            IKey        associationKey;
            ITable      associationTable = entity.GetAssociationTable(directedReference.ToEntity, out cardinalityPrimary, out cardinalityForeign, out mainKey, out associationKey);

            key            keyNode          = new key();
            List <IColumn> fromInPrimaryKey = new List <IColumn>();
            List <IColumn> toInPrimaryKey   = new List <IColumn>();

            if (fromPrimaryMappedTable == toPrimaryMappedTable)
            {
                // This many-to-many relationship is to the same table
                if (manyToManySameTableProcessingCounts.ContainsKey(toPrimaryMappedTable))
                {
                    int index = manyToManySameTableProcessingCounts[toPrimaryMappedTable];
                    index++;
                    fromInPrimaryKey.AddRange(referenceMappedTable.Relationships.Where(t => t.PrimaryTable == fromPrimaryMappedTable).ElementAt(index).PrimaryKey.Columns);
                    toInPrimaryKey.AddRange(referenceMappedTable.Relationships.Where(t => t.PrimaryTable == toPrimaryMappedTable).ElementAt(index).ForeignKey.Columns);
                    manyToManySameTableProcessingCounts[toPrimaryMappedTable] = index;
                }
                else
                {
                    fromInPrimaryKey.AddRange(referenceMappedTable.Relationships.Where(t => t.PrimaryTable == fromPrimaryMappedTable).ElementAt(0).PrimaryKey.Columns);
                    toInPrimaryKey.AddRange(referenceMappedTable.Relationships.Where(t => t.PrimaryTable == toPrimaryMappedTable).ElementAt(0).ForeignKey.Columns);
                    manyToManySameTableProcessingCounts.Add(toPrimaryMappedTable, 0);
                }
            }
            else
            {
                foreach (var coll in referenceMappedTable.Relationships.Where(t => t.PrimaryTable == fromPrimaryMappedTable).Select(r => r.ForeignKey.Columns))
                {
                    foreach (var c in coll)
                    {
                        fromInPrimaryKey.Add(c);
                    }
                }

                foreach (var coll in referenceMappedTable.Relationships.Where(t => t.PrimaryTable == toPrimaryMappedTable).Select(r => r.ForeignKey.Columns))
                {
                    foreach (var c in coll)
                    {
                        toInPrimaryKey.Add(c);
                    }
                }
            }

            if (fromInPrimaryKey.Count() == 1)
            {
                keyNode.column1 = fromInPrimaryKey.First().Name.BackTick();
            }
            else
            {
                foreach (var columnNode in GetColumnNodes(fromInPrimaryKey))
                {
                    keyNode.AddColumn(columnNode);
                }
            }

            manytomany manyToManyNode = new manytomany();

            manyToManyNode.@class = directedReference.ToEntity.Name;

            if (toInPrimaryKey.Count() == 1)
            {
                manyToManyNode.column = toInPrimaryKey.First().Name.BackTick();
            }
            else
            {
                foreach (var columnNode in GetColumnNodes(toInPrimaryKey))
                {
                    keyNode.AddColumn(columnNode);
                }
            }

            collectionFetchMode collFetchMode;

            if (directedReference.Entity1IsFromEnd)
            {
                collFetchMode = (collectionFetchMode)Enum.Parse(typeof(collectionFetchMode), directedReference.Reference.GetReferenceEnd1CollectionFetchMode().ToString(), true);
            }
            else
            {
                collFetchMode = (collectionFetchMode)Enum.Parse(typeof(collectionFetchMode), directedReference.Reference.GetReferenceEnd2CollectionFetchMode().ToString(), true);
            }

            AssociationType type = NHCollections.GetAssociationType(directedReference);

            switch (type)
            {
            case AssociationType.None:
                Log.WarnFormat("No association type was set on reference {0} for the end {1}. This is usually an error.", directedReference.Reference.Name, directedReference.Entity1IsFromEnd ? "One" : "Two");
                return;

            case AssociationType.Set:
                set setNode = CreateSetNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
                setNode.table = referenceMappedTable.Name.BackTick();
                setNode.Item  = manyToManyNode;

                if (orderByClause.Length > 0)
                {
                    setNode.orderby = orderByClause;
                }

                addItem(setNode);
                break;

            case AssociationType.Bag:
                bag bagNode = CreateBagNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
                bagNode.table = referenceMappedTable.Name.BackTick();
                bagNode.Item  = manyToManyNode;

                if (orderByClause.Length > 0)
                {
                    bagNode.orderby = orderByClause;
                }

                addItem(bagNode);
                break;

            case AssociationType.Map:
                map mapNode = CreateMapNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
                mapNode.table = referenceMappedTable.Name.BackTick();
                mapNode.Item  = new index
                {
                    column1 = NHCollections.GetIndexColumnName(directedReference),
                    type    = NHCollections.GetIndexColumnTypeName(directedReference, toPrimaryMappedTable /*fromPrimaryMappedTable*/)
                };
                mapNode.Item1 = manyToManyNode;

                if (orderByClause.Length > 0)
                {
                    mapNode.orderby = orderByClause;
                }

                addItem(mapNode);
                break;

            case AssociationType.List:
                list listNode = CreateListNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
                listNode.table = referenceMappedTable.Name.BackTick();
                listNode.Item  = new index
                {
                    column1 = NHCollections.GetIndexColumnName(directedReference),
                };
                listNode.Item1 = manyToManyNode;

                if (orderByClause.Length > 0)
                {
                    listNode.orderby = orderByClause;
                }

                addItem(listNode);
                break;

            // case AssociationType.IDBag:
            //     throw new NotImplementedException(
            //         string.Format("Have not implemented {0} association type for Many To Many relationships", type));
            default:
                throw new NotImplementedException("AssociationType not handled yet: " + type.ToString());
            }
        }
コード例 #24
0
 MemSet(key, value);
コード例 #25
0
 set => Set(key, value, false);
コード例 #26
0
 set => this.Set(key, value);
コード例 #27
0
 set => SetValue(key, value);
コード例 #28
0
ファイル: MemoryCache.cs プロジェクト: snowy-desire/seterator
 set => setValue(key, value);
コード例 #29
0
 foreach (var(key, value) in keyValuePairs)
コード例 #30
0
 set => Setter(key, value);
コード例 #31
0
ファイル: Settings.cs プロジェクト: rajeshwarn/Thingy
 get => Get(key, defaultValue);
コード例 #32
0
 set => Setter2(key, value);
コード例 #33
0
ファイル: EnumDictionary.cs プロジェクト: dek0058/Dark-Tower
 set => Add(key, value);
コード例 #34
0
 (Key, IsDefault) = (IsNotEmptyOrWhiteSpace(key, nameof(key)), false);
コード例 #35
0
 FromECPrivateKey(key, algId, out ret);
コード例 #36
0
ファイル: HtmlTag.cs プロジェクト: harpreet/fubumvc
 key => { throw new KeyNotFoundException("Does not have html attribute '{0}'".ToFormat(key));
コード例 #37
0
ファイル: SolutionGraph.cs プロジェクト: bobpace/ripple
throw new InvalidSolutionException(key);
コード例 #38
0
ファイル: KeyScript.cs プロジェクト: Shad0wKing92/MusicTheory
	// Use this for initialization
	void Start () {

		//keyInZone = NoteMovement.inZone;
//		GameObject notes = GameObject.FindGameObjectWithTag("Note");
		NoteMovement noteMovement = notes.GetComponent<NoteMovement>();
		//noteScript = gameObject.GetComponent<GameObject>();

		if(keyName == "MiddleC"){
			currentKey = key.MiddleC;
		}
		if(keyName == "CSharp"){
			currentKey = key.CSharp;
		}
		if(keyName == "D"){
			currentKey = key.D;
		}
		if(keyName == "DSharp"){
			currentKey = key.DSharp;
		}
		if(keyName == "E"){
			currentKey = key.E;
		}
		if(keyName == "F"){
			currentKey = key.F;
		}
		if (keyName == "FSharp") {
			currentKey = key.FSharp;
		}
		if(keyName == "G"){
			currentKey = key.G;
		}
		if (keyName == "GSharp") {
			currentKey = key.GSharp;
		}
		if(keyName == "A"){
			currentKey = key.A;
		}
		if (keyName == "ASharp") {
			currentKey = key.ASharp;
		}
		if(keyName == "B"){
			currentKey = key.B;
		}
		if(keyName == "HighC"){
			currentKey = key.HighC;
		}
		if (keyName == "HighCSharp") {
			currentKey = key.HighCSharp;
		}
		if(keyName == "HighD"){
			currentKey = key.HighD;
		}
		if (keyName == "HighDSharp") {
			currentKey = key.HighDSharp;
		}
		if(keyName == "HighE"){
			currentKey = key.HighE;
		}
		if(keyName == "HighF"){
			currentKey = key.HighF;
		}
	}
コード例 #39
0
ファイル: jhl.Utility.cs プロジェクト: ssg100/ninjaindicators
		public static SortList instance(IDataSeries input, int period)
		{
			if ( input == null )
				return new SortList(input, period);
			lock(dict) {
				key k = new key(input, period);
				if ( dict.ContainsKey(k) )
					return dict[k];
				else
					return dict[k] = new SortList(input, period);
			}
		}		
コード例 #40
0
 get => Indexer_Get(key); set => Indexer_Set(key, value);
コード例 #41
0
 set => Alloc(key, value, true);
コード例 #42
0
 set => Assign(key, value);
コード例 #43
0
ファイル: Map.cs プロジェクト: jodufra/unhibernate
 set => Insert(key, value, false);
コード例 #44
0
 set => this.Add(key, value);
コード例 #45
0
ファイル: KeyboardSimulator.cs プロジェクト: hoki/HokiMacro
 public static void KeyPress(key key, int delay = 0)
 {
     if (key != key.Null)
     {
         KeyPressDI(Keys.GetDxKey(key), delay);
         //if(delay < 1)
         //{
         //    KeyDown((byte)key);
         //    KeyUp((byte)key);
         //}
         //else
         //{
         //    KeyDown((byte)key);
         //    System.Threading.Thread.Sleep(delay);
         //    KeyUp((byte)key);
         //}
     }
 }
コード例 #46
0
ファイル: GlobalHook.cs プロジェクト: hoki/HokiMacro
        public static dxKey GetDxKey(key key)
        {
            switch (key)
            {
                case key.zero_numpad: return dxKey.zero_numpad;
                case key.one_numpad: return dxKey.one_numpad;
                case key.two_numpad: return dxKey.two_numpad;
                case key.three_numpad: return dxKey.three_numpad;
                case key.four_numpad: return dxKey.four_numpad;
                case key.five_numpad: return dxKey.five_numpad;
                case key.six_numpad: return dxKey.six_numpad;
                case key.seven_numpad: return dxKey.seven_numpad;
                case key.eight_numpad: return dxKey.eight_numpad;
                case key.nine_numpad: return dxKey.nine_numpad;

                case key.numlock: return dxKey.numlock;
                case key.forwardSlash_numpad: return dxKey.forwardSlash_numpad;
                case key.asterisk_numpad: return dxKey.asterisk_numpad;
                case key.dash_numpad: return dxKey.dash_numpad;
                case key.plus_numpad: return dxKey.plus_numpad;
                case key.period_numpad: return dxKey.period_numpad;

                case key.five_numlock_numpad: return dxKey.five_numlock_numpad;

                case key.printScreen: return dxKey.printScreen;
                case key.scrollLock: return dxKey.scrollLock;
                case key.pauseBreak: return dxKey.pauseBreak;

                case key.insert: return dxKey.insert;
                case key.home: return dxKey.home;
                case key.pageUp: return dxKey.pageUp;
                case key.delete: return dxKey.delete;
                case key.end: return dxKey.end;
                case key.pageDown: return dxKey.pageDown;

                case key.leftArrow: return dxKey.leftArrow;
                case key.upArrow: return dxKey.upArrow;
                case key.rightArrow: return dxKey.rightArrow;
                case key.downArrow: return dxKey.downArrow;

                case key.f1: return dxKey.f1;
                case key.f2: return dxKey.f2;
                case key.f3: return dxKey.f3;
                case key.f4: return dxKey.f4;
                case key.f5: return dxKey.f5;
                case key.f6: return dxKey.f6;
                case key.f7: return dxKey.f7;
                case key.f8: return dxKey.f8;
                case key.f9: return dxKey.f9;
                case key.f10: return dxKey.f10;
                case key.f11: return dxKey.f11;
                case key.f12: return dxKey.f12;

                case key.escape: return dxKey.escape;

                case key.tilde: return dxKey.tilde;
                case key.one: return dxKey.one;
                case key.two: return dxKey.two;
                case key.three: return dxKey.three;
                case key.four: return dxKey.four;
                case key.five: return dxKey.five;
                case key.six: return dxKey.six;
                case key.seven: return dxKey.seven;
                case key.eight: return dxKey.eight;
                case key.nine: return dxKey.nine;
                case key.zero: return dxKey.zero;
                case key.dash: return dxKey.dash;
                case key.equals: return dxKey.equals;
                case key.backspace: return dxKey.backspace;

                case key.tab: return dxKey.tab;
                case key.Q: return dxKey.Q;
                case key.W: return dxKey.W;
                case key.E: return dxKey.E;
                case key.R: return dxKey.R;
                case key.T: return dxKey.T;
                case key.Y: return dxKey.Y;
                case key.U: return dxKey.U;
                case key.I: return dxKey.I;
                case key.O: return dxKey.O;
                case key.P: return dxKey.P;
                case key.bracket_open: return dxKey.bracket_open;
                case key.bracket_close: return dxKey.bracket_close;
                case key.backSlash: return dxKey.backSlash;

                case key.capsLock: return dxKey.capsLock;
                case key.A: return dxKey.A;
                case key.S: return dxKey.S;
                case key.D: return dxKey.D;
                case key.F: return dxKey.F;
                case key.G: return dxKey.G;
                case key.H: return dxKey.H;
                case key.J: return dxKey.J;
                case key.K: return dxKey.K;
                case key.L: return dxKey.L;
                case key.semiColon: return dxKey.semiColon;
                case key.quote: return dxKey.quote;
                case key.enter: return dxKey.enter;

                case key.shift_left: return dxKey.shift_left;
                case key.Z: return dxKey.Z;
                case key.X: return dxKey.X;
                case key.C: return dxKey.C;
                case key.V: return dxKey.V;
                case key.B: return dxKey.B;
                case key.N: return dxKey.N;
                case key.M: return dxKey.M;
                case key.comma: return dxKey.comma;
                case key.period: return dxKey.period;
                case key.forwardSlash: return dxKey.forwardSlash;
                case key.shift_right: return dxKey.shift_right;

                case key.control_left: return dxKey.control_left;
                case key.windows_left: return dxKey.windows_left;
                case key.alt_left: return dxKey.alt_left;
                case key.spacebar: return dxKey.spacebar;
                case key.alt_right: return dxKey.alt_right;
                case key.windows_right: return dxKey.windows_right;
                case key.menu: return dxKey.menu;
                case key.control_right: return dxKey.control_right;
                default: return dxKey.Null;
            }
        }