Added UIX.RenderApi

MicrosoftIris.sln

@@ -1,10 +1,12 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
+# Visual Studio Version 16
-VisualStudioVersion = 17.0.32112.339
+VisualStudioVersion = 16.0.31727.386
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UIX", "UIX\UIX.csproj", "{78A8B08C-C0E9-4BAC-9AF6-58D3A55C05C9}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UIX.RenderApi", "UIX.RenderApi\UIX.RenderApi.csproj", "{CB2B7609-C7B8-4E2A-82D8-DD631B70B621}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,6 +17,10 @@ Global
 		{78A8B08C-C0E9-4BAC-9AF6-58D3A55C05C9}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{78A8B08C-C0E9-4BAC-9AF6-58D3A55C05C9}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{78A8B08C-C0E9-4BAC-9AF6-58D3A55C05C9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CB2B7609-C7B8-4E2A-82D8-DD631B70B621}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CB2B7609-C7B8-4E2A-82D8-DD631B70B621}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CB2B7609-C7B8-4E2A-82D8-DD631B70B621}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CB2B7609-C7B8-4E2A-82D8-DD631B70B621}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

UIX.RenderApi/AssemblyInfo.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security.Permissions;
+
+[assembly: ComVisible(false)]
+[assembly: StringFreezing]
+[assembly: AssemblyProduct("Microsoft (R) Windows (R) Operating System")]
+[assembly: AssemblyCopyright("Copyright (c) Microsoft Corporation. All rights reserved.")]
+[assembly: AssemblyDescription("UIX.RenderApi.Skia")]
+[assembly: AssemblyTitle("UIX.RenderApi.Skia")]
+[assembly: CLSCompliant(false)]
+[assembly: AssemblyDelaySign(true)]
+[assembly: AssemblyFileVersion("4.8.0015.0")]
+[assembly: AssemblyCompany("Microsoft Corporation")]
+[assembly: AssemblyVersion("4.8.0.0")]
+[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]

UIX.RenderApi/Cn/CodeGenNameAttribute.cs

@@ -0,0 +1,20 @@
+// Decompiled with JetBrains decompiler
+// Type: Cn.CodeGenNameAttribute
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+using System.Diagnostics;
+
+namespace Cn
+{
+    [Conditional("NEVER")]
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
+    public class CodeGenNameAttribute : Attribute
+    {
+        public string Name;
+
+        public CodeGenNameAttribute(string stName) => this.Name = stName;
+    }
+}

UIX.RenderApi/Cn/DisposeMethodAttribute.cs

@@ -0,0 +1,17 @@
+// Decompiled with JetBrains decompiler
+// Type: Cn.DisposeMethodAttribute
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+using System.Diagnostics;
+
+namespace Cn
+{
+    [Conditional("NEVER")]
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
+    public class DisposeMethodAttribute : Attribute
+    {
+    }
+}

UIX.RenderApi/Cn/GCCollectSafeAttribute.cs

@@ -0,0 +1,17 @@
+// Decompiled with JetBrains decompiler
+// Type: Cn.GCCollectSafeAttribute
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+using System.Diagnostics;
+
+namespace Cn
+{
+    [Conditional("NEVER")]
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
+    public class GCCollectSafeAttribute : Attribute
+    {
+    }
+}

UIX.RenderApi/Cn/PartialCollectAttribute.cs

@@ -0,0 +1,17 @@
+// Decompiled with JetBrains decompiler
+// Type: Cn.PartialCollectAttribute
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+using System.Diagnostics;
+
+namespace Cn
+{
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
+    [Conditional("NEVER")]
+    public class PartialCollectAttribute : Attribute
+    {
+    }
+}

UIX.RenderApi/Cn/ReflectionAttribute.cs

@@ -0,0 +1,17 @@
+// Decompiled with JetBrains decompiler
+// Type: Cn.ReflectionAttribute
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+using System.Diagnostics;
+
+namespace Cn
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
+    [Conditional("NEVER")]
+    public class ReflectionAttribute : Attribute
+    {
+    }
+}

UIX.RenderApi/Cn/TypeInitializeDependencyAttribute.cs

@@ -0,0 +1,20 @@
+// Decompiled with JetBrains decompiler
+// Type: Cn.TypeInitializeDependencyAttribute
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+using System.Diagnostics;
+
+namespace Cn
+{
+    [Conditional("NEVER")]
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true, Inherited = false)]
+    public class TypeInitializeDependencyAttribute : Attribute
+    {
+        public Type Type;
+
+        public TypeInitializeDependencyAttribute(Type type) => this.Type = type;
+    }
+}

UIX.RenderApi/IVector.cs

@@ -0,0 +1,12 @@
+// Decompiled with JetBrains decompiler
+// Type: IVector
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+public interface IVector
+{
+    int Count { get; }
+
+    object this[int index] { get; }
+}

UIX.RenderApi/KeyValueEntry.cs

@@ -0,0 +1,21 @@
+// Decompiled with JetBrains decompiler
+// Type: KeyValueEntry
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+public struct KeyValueEntry
+{
+    private object _key;
+    private object _value;
+
+    public KeyValueEntry(object key, object value)
+    {
+        this._key = key;
+        this._value = value;
+    }
+
+    public object Key => this._key;
+
+    public object Value => this._value;
+}

UIX.RenderApi/KeyValueEntry`2.cs

@@ -0,0 +1,21 @@
+// Decompiled with JetBrains decompiler
+// Type: KeyValueEntry`2
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+public struct KeyValueEntry<K, V>
+{
+    private K _key;
+    private V _value;
+
+    public KeyValueEntry(K key, V value)
+    {
+        this._key = key;
+        this._value = value;
+    }
+
+    public K Key => this._key;
+
+    public V Value => this._value;
+}

UIX.RenderApi/Map.cs

@@ -0,0 +1,329 @@
+// Decompiled with JetBrains decompiler
+// Type: Map
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+using System.Collections.Generic;
+
+public class Map
+{
+    private int[] _buckets;
+    private Map.Entry[] _entries;
+    private int _count;
+    private int _version;
+    private int _freeList;
+    private int _freeCount;
+
+    public Map()
+      : this(0)
+    {
+    }
+
+    public Map(int capacity)
+    {
+        if (capacity <= 0)
+            return;
+        this.Initialize(capacity);
+    }
+
+    public int Count => this._count - this._freeCount;
+
+    public Map.KeyCollection Keys => new Map.KeyCollection(this);
+
+    public Map.ValueCollection Values => new Map.ValueCollection(this);
+
+    public object this[object key]
+    {
+        get
+        {
+            int entry = this.FindEntry(key);
+            return entry >= 0 ? this._entries[entry].value : null;
+        }
+        set => this.Insert(key, value, false);
+    }
+
+    public void Add(object key, object value) => this.Insert(key, value, true);
+
+    public void Clear()
+    {
+        if (this._count <= 0)
+            return;
+        for (int index = 0; index < this._buckets.Length; ++index)
+            this._buckets[index] = -1;
+        Array.Clear(_entries, 0, this._count);
+        this._freeList = -1;
+        this._count = 0;
+        this._freeCount = 0;
+    }
+
+    public bool ContainsKey(object key) => this.FindEntry(key) >= 0;
+
+    public Map.Enumerator GetEnumerator() => new Map.Enumerator(this);
+
+    private int FindEntry(object key)
+    {
+        if (this._buckets != null)
+        {
+            int num = this.GetKeyHashCode(key) & int.MaxValue;
+            for (int index = this._buckets[num % this._buckets.Length]; index >= 0; index = this._entries[index].next)
+            {
+                if (this._entries[index].hashCode == num && this.KeyEquals(this._entries[index].key, key))
+                    return index;
+            }
+        }
+        return -1;
+    }
+
+    private void Initialize(int capacity)
+    {
+        int prime = HashHelpers.GetPrime(capacity);
+        this._buckets = new int[prime];
+        for (int index = 0; index < this._buckets.Length; ++index)
+            this._buckets[index] = -1;
+        this._entries = new Map.Entry[prime];
+        this._freeList = -1;
+    }
+
+    private void Insert(object key, object value, bool add)
+    {
+        if (this._buckets == null)
+            this.Initialize(0);
+        int num = this.GetKeyHashCode(key) & int.MaxValue;
+        for (int index = this._buckets[num % this._buckets.Length]; index >= 0; index = this._entries[index].next)
+        {
+            if (this._entries[index].hashCode == num && this.KeyEquals(this._entries[index].key, key))
+            {
+                if (add)
+                    throw new ArgumentException("Adding duplicate entry to Dictionary");
+                this._entries[index].value = value;
+                ++this._version;
+                return;
+            }
+        }
+        int index1;
+        if (this._freeCount > 0)
+        {
+            index1 = this._freeList;
+            this._freeList = this._entries[index1].next;
+            --this._freeCount;
+        }
+        else
+        {
+            if (this._count == this._entries.Length)
+                this.Resize();
+            index1 = this._count;
+            ++this._count;
+        }
+        int index2 = num % this._buckets.Length;
+        this._entries[index1].hashCode = num;
+        this._entries[index1].next = this._buckets[index2];
+        this._entries[index1].key = key;
+        this._entries[index1].value = value;
+        this._buckets[index2] = index1;
+        ++this._version;
+    }
+
+    private void Resize()
+    {
+        int prime = HashHelpers.GetPrime(this._count * 2);
+        int[] numArray = new int[prime];
+        for (int index = 0; index < numArray.Length; ++index)
+            numArray[index] = -1;
+        Map.Entry[] entryArray = new Map.Entry[prime];
+        Array.Copy(_entries, 0, entryArray, 0, this._count);
+        for (int index1 = 0; index1 < this._count; ++index1)
+        {
+            int index2 = entryArray[index1].hashCode % prime;
+            entryArray[index1].next = numArray[index2];
+            numArray[index2] = index1;
+        }
+        this._buckets = numArray;
+        this._entries = entryArray;
+    }
+
+    public bool Remove(object key)
+    {
+        if (this._buckets != null)
+        {
+            int num = this.GetKeyHashCode(key) & int.MaxValue;
+            int index1 = num % this._buckets.Length;
+            int index2 = -1;
+            for (int index3 = this._buckets[index1]; index3 >= 0; index3 = this._entries[index3].next)
+            {
+                if (this._entries[index3].hashCode == num && this.KeyEquals(this._entries[index3].key, key))
+                {
+                    if (index2 < 0)
+                        this._buckets[index1] = this._entries[index3].next;
+                    else
+                        this._entries[index2].next = this._entries[index3].next;
+                    this._entries[index3].hashCode = -1;
+                    this._entries[index3].next = this._freeList;
+                    this._entries[index3].key = null;
+                    this._entries[index3].value = null;
+                    this._freeList = index3;
+                    ++this._freeCount;
+                    ++this._version;
+                    return true;
+                }
+                index2 = index3;
+            }
+        }
+        return false;
+    }
+
+    public bool TryGetValue(object key, out object value)
+    {
+        int entry = this.FindEntry(key);
+        if (entry >= 0)
+        {
+            value = this._entries[entry].value;
+            return true;
+        }
+        value = null;
+        return false;
+    }
+
+    private bool KeyEquals(object x, object y) => x.Equals(y);
+
+    private int GetKeyHashCode(object obj) => obj.GetHashCode();
+
+    public struct Enumerator
+    {
+        private Map _dictionary;
+        private int _version;
+        private int _index;
+        private KeyValueEntry<object, object> _current;
+
+        internal Enumerator(Map dictionary)
+        {
+            this._dictionary = dictionary;
+            this._version = this._dictionary._version;
+            this._index = 0;
+            this._current = new KeyValueEntry<object, object>(null, null);
+        }
+
+        public bool MoveNext()
+        {
+            if (this._version != this._dictionary._version)
+                throw new InvalidOperationException("Dictionary was modified while enumerating");
+            for (; (uint)this._index < (uint)this._dictionary._count; ++this._index)
+            {
+                if (this._dictionary._entries[this._index].hashCode >= 0)
+                {
+                    this._current = new KeyValueEntry<object, object>(this._dictionary._entries[this._index].key, this._dictionary._entries[this._index].value);
+                    ++this._index;
+                    return true;
+                }
+            }
+            this._index = this._dictionary._count + 1;
+            this._current = new KeyValueEntry<object, object>(null, null);
+            return false;
+        }
+
+        public KeyValueEntry<object, object> Current => this._current;
+    }
+
+    public struct KeyCollection
+    {
+        private Map _dictionary;
+
+        public KeyCollection(Map dictionary) => this._dictionary = dictionary != null ? dictionary : throw new ArgumentNullException(nameof(dictionary));
+
+        public Map.KeyCollection.Enumerator GetEnumerator() => new Map.KeyCollection.Enumerator(this._dictionary);
+
+        public int Count => this._dictionary.Count;
+
+        public struct Enumerator
+        {
+            private Map _dictionary;
+            private int _index;
+            private int _version;
+            private object _currentKey;
+
+            internal Enumerator(Map dictionary)
+            {
+                this._dictionary = dictionary;
+                this._version = dictionary._version;
+                this._index = 0;
+                this._currentKey = null;
+            }
+
+            public bool MoveNext()
+            {
+                if (this._version != this._dictionary._version)
+                    throw new InvalidOperationException("Dictionary was modified while enumerating");
+                for (; (uint)this._index < (uint)this._dictionary._count; ++this._index)
+                {
+                    if (this._dictionary._entries[this._index].hashCode >= 0)
+                    {
+                        this._currentKey = this._dictionary._entries[this._index].key;
+                        ++this._index;
+                        return true;
+                    }
+                }
+                this._index = this._dictionary._count + 1;
+                this._currentKey = null;
+                return false;
+            }
+
+            public object Current => this._currentKey;
+        }
+    }
+
+    public struct ValueCollection
+    {
+        private Map _dictionary;
+
+        public ValueCollection(Map dictionary) => this._dictionary = dictionary != null ? dictionary : throw new ArgumentNullException(nameof(dictionary));
+
+        public Map.ValueCollection.Enumerator GetEnumerator() => new Map.ValueCollection.Enumerator(this._dictionary);
+
+        public int Count => this._dictionary.Count;
+
+        public struct Enumerator
+        {
+            private Map _dictionary;
+            private int _index;
+            private int _version;
+            private object _currentValue;
+
+            internal Enumerator(Map dictionary)
+            {
+                this._dictionary = dictionary;
+                this._version = dictionary._version;
+                this._index = 0;
+                this._currentValue = null;
+            }
+
+            public bool MoveNext()
+            {
+                if (this._version != this._dictionary._version)
+                    throw new InvalidOperationException("Dictionary was modified while enumerating");
+                for (; (uint)this._index < (uint)this._dictionary._count; ++this._index)
+                {
+                    if (this._dictionary._entries[this._index].hashCode >= 0)
+                    {
+                        this._currentValue = this._dictionary._entries[this._index].value;
+                        ++this._index;
+                        return true;
+                    }
+                }
+                this._index = this._dictionary._count + 1;
+                this._currentValue = null;
+                return false;
+            }
+
+            public object Current => this._currentValue;
+        }
+    }
+
+    private struct Entry
+    {
+        public int hashCode;
+        public int next;
+        public object key;
+        public object value;
+    }
+}

UIX.RenderApi/Map`2.cs

@@ -0,0 +1,329 @@
+// Decompiled with JetBrains decompiler
+// Type: Map`2
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+using System.Collections.Generic;
+
+public class Map<K, V>
+{
+    private int[] _buckets;
+    private Map<K, V>.Entry[] _entries;
+    private int _count;
+    private int _version;
+    private int _freeList;
+    private int _freeCount;
+
+    public Map()
+      : this(0)
+    {
+    }
+
+    public Map(int capacity)
+    {
+        if (capacity <= 0)
+            return;
+        this.Initialize(capacity);
+    }
+
+    public int Count => this._count - this._freeCount;
+
+    public Map<K, V>.KeyCollection Keys => new Map<K, V>.KeyCollection(this);
+
+    public Map<K, V>.ValueCollection Values => new Map<K, V>.ValueCollection(this);
+
+    public V this[K key]
+    {
+        get
+        {
+            int entry = this.FindEntry(key);
+            return entry >= 0 ? this._entries[entry].value : default(V);
+        }
+        set => this.Insert(key, value, false);
+    }
+
+    public void Add(K key, V value) => this.Insert(key, value, true);
+
+    public void Clear()
+    {
+        if (this._count <= 0)
+            return;
+        for (int index = 0; index < this._buckets.Length; ++index)
+            this._buckets[index] = -1;
+        Array.Clear(_entries, 0, this._count);
+        this._freeList = -1;
+        this._count = 0;
+        this._freeCount = 0;
+    }
+
+    public bool ContainsKey(K key) => this.FindEntry(key) >= 0;
+
+    public Map<K, V>.Enumerator GetEnumerator() => new Map<K, V>.Enumerator(this);
+
+    private int FindEntry(K key)
+    {
+        if (this._buckets != null)
+        {
+            int num = this.GetKeyHashCode(key) & int.MaxValue;
+            for (int index = this._buckets[num % this._buckets.Length]; index >= 0; index = this._entries[index].next)
+            {
+                if (this._entries[index].hashCode == num && this.KeyEquals(this._entries[index].key, key))
+                    return index;
+            }
+        }
+        return -1;
+    }
+
+    private void Initialize(int capacity)
+    {
+        int prime = HashHelpers.GetPrime(capacity);
+        this._buckets = new int[prime];
+        for (int index = 0; index < this._buckets.Length; ++index)
+            this._buckets[index] = -1;
+        this._entries = new Map<K, V>.Entry[prime];
+        this._freeList = -1;
+    }
+
+    private void Insert(K key, V value, bool add)
+    {
+        if (this._buckets == null)
+            this.Initialize(0);
+        int num = this.GetKeyHashCode(key) & int.MaxValue;
+        for (int index = this._buckets[num % this._buckets.Length]; index >= 0; index = this._entries[index].next)
+        {
+            if (this._entries[index].hashCode == num && this.KeyEquals(this._entries[index].key, key))
+            {
+                if (add)
+                    throw new ArgumentException("Adding duplicate entry to Dictionary");
+                this._entries[index].value = value;
+                ++this._version;
+                return;
+            }
+        }
+        int index1;
+        if (this._freeCount > 0)
+        {
+            index1 = this._freeList;
+            this._freeList = this._entries[index1].next;
+            --this._freeCount;
+        }
+        else
+        {
+            if (this._count == this._entries.Length)
+                this.Resize();
+            index1 = this._count;
+            ++this._count;
+        }
+        int index2 = num % this._buckets.Length;
+        this._entries[index1].hashCode = num;
+        this._entries[index1].next = this._buckets[index2];
+        this._entries[index1].key = key;
+        this._entries[index1].value = value;
+        this._buckets[index2] = index1;
+        ++this._version;
+    }
+
+    private void Resize()
+    {
+        int prime = HashHelpers.GetPrime(this._count * 2);
+        int[] numArray = new int[prime];
+        for (int index = 0; index < numArray.Length; ++index)
+            numArray[index] = -1;
+        Map<K, V>.Entry[] entryArray = new Map<K, V>.Entry[prime];
+        Array.Copy(_entries, 0, entryArray, 0, this._count);
+        for (int index1 = 0; index1 < this._count; ++index1)
+        {
+            int index2 = entryArray[index1].hashCode % prime;
+            entryArray[index1].next = numArray[index2];
+            numArray[index2] = index1;
+        }
+        this._buckets = numArray;
+        this._entries = entryArray;
+    }
+
+    public bool Remove(K key)
+    {
+        if (this._buckets != null)
+        {
+            int num = this.GetKeyHashCode(key) & int.MaxValue;
+            int index1 = num % this._buckets.Length;
+            int index2 = -1;
+            for (int index3 = this._buckets[index1]; index3 >= 0; index3 = this._entries[index3].next)
+            {
+                if (this._entries[index3].hashCode == num && this.KeyEquals(this._entries[index3].key, key))
+                {
+                    if (index2 < 0)
+                        this._buckets[index1] = this._entries[index3].next;
+                    else
+                        this._entries[index2].next = this._entries[index3].next;
+                    this._entries[index3].hashCode = -1;
+                    this._entries[index3].next = this._freeList;
+                    this._entries[index3].key = default(K);
+                    this._entries[index3].value = default(V);
+                    this._freeList = index3;
+                    ++this._freeCount;
+                    ++this._version;
+                    return true;
+                }
+                index2 = index3;
+            }
+        }
+        return false;
+    }
+
+    public bool TryGetValue(K key, out V value)
+    {
+        int entry = this.FindEntry(key);
+        if (entry >= 0)
+        {
+            value = this._entries[entry].value;
+            return true;
+        }
+        value = default(V);
+        return false;
+    }
+
+    private bool KeyEquals(K x, K y) => x.Equals(y);
+
+    private int GetKeyHashCode(K obj) => obj.GetHashCode();
+
+    public struct Enumerator
+    {
+        private Map<K, V> _dictionary;
+        private int _version;
+        private int _index;
+        private KeyValueEntry<K, V> _current;
+
+        internal Enumerator(Map<K, V> dictionary)
+        {
+            this._dictionary = dictionary;
+            this._version = this._dictionary._version;
+            this._index = 0;
+            this._current = new KeyValueEntry<K, V>(default(K), default(V));
+        }
+
+        public bool MoveNext()
+        {
+            if (this._version != this._dictionary._version)
+                throw new InvalidOperationException("Dictionary was modified while enumerating");
+            for (; (uint)this._index < (uint)this._dictionary._count; ++this._index)
+            {
+                if (this._dictionary._entries[this._index].hashCode >= 0)
+                {
+                    this._current = new KeyValueEntry<K, V>(this._dictionary._entries[this._index].key, this._dictionary._entries[this._index].value);
+                    ++this._index;
+                    return true;
+                }
+            }
+            this._index = this._dictionary._count + 1;
+            this._current = new KeyValueEntry<K, V>(default(K), default(V));
+            return false;
+        }
+
+        public KeyValueEntry<K, V> Current => this._current;
+    }
+
+    public struct KeyCollection
+    {
+        private Map<K, V> _dictionary;
+
+        public KeyCollection(Map<K, V> dictionary) => this._dictionary = dictionary != null ? dictionary : throw new ArgumentNullException(nameof(dictionary));
+
+        public Map<K, V>.KeyCollection.Enumerator GetEnumerator() => new Map<K, V>.KeyCollection.Enumerator(this._dictionary);
+
+        public int Count => this._dictionary.Count;
+
+        public struct Enumerator
+        {
+            private Map<K, V> _dictionary;
+            private int _index;
+            private int _version;
+            private K _currentKey;
+
+            internal Enumerator(Map<K, V> dictionary)
+            {
+                this._dictionary = dictionary;
+                this._version = dictionary._version;
+                this._index = 0;
+                this._currentKey = default(K);
+            }
+
+            public bool MoveNext()
+            {
+                if (this._version != this._dictionary._version)
+                    throw new InvalidOperationException("Dictionary was modified while enumerating");
+                for (; (uint)this._index < (uint)this._dictionary._count; ++this._index)
+                {
+                    if (this._dictionary._entries[this._index].hashCode >= 0)
+                    {
+                        this._currentKey = this._dictionary._entries[this._index].key;
+                        ++this._index;
+                        return true;
+                    }
+                }
+                this._index = this._dictionary._count + 1;
+                this._currentKey = default(K);
+                return false;
+            }
+
+            public K Current => this._currentKey;
+        }
+    }
+
+    public struct ValueCollection
+    {
+        private Map<K, V> _dictionary;
+
+        public ValueCollection(Map<K, V> dictionary) => this._dictionary = dictionary != null ? dictionary : throw new ArgumentNullException(nameof(dictionary));
+
+        public Map<K, V>.ValueCollection.Enumerator GetEnumerator() => new Map<K, V>.ValueCollection.Enumerator(this._dictionary);
+
+        public int Count => this._dictionary.Count;
+
+        public struct Enumerator
+        {
+            private Map<K, V> _dictionary;
+            private int _index;
+            private int _version;
+            private V _currentValue;
+
+            internal Enumerator(Map<K, V> dictionary)
+            {
+                this._dictionary = dictionary;
+                this._version = dictionary._version;
+                this._index = 0;
+                this._currentValue = default(V);
+            }
+
+            public bool MoveNext()
+            {
+                if (this._version != this._dictionary._version)
+                    throw new InvalidOperationException("Dictionary was modified while enumerating");
+                for (; (uint)this._index < (uint)this._dictionary._count; ++this._index)
+                {
+                    if (this._dictionary._entries[this._index].hashCode >= 0)
+                    {
+                        this._currentValue = this._dictionary._entries[this._index].value;
+                        ++this._index;
+                        return true;
+                    }
+                }
+                this._index = this._dictionary._count + 1;
+                this._currentValue = default(V);
+                return false;
+            }
+
+            public V Current => this._currentValue;
+        }
+    }
+
+    private struct Entry
+    {
+        public int hashCode;
+        public int next;
+        public K key;
+        public V value;
+    }
+}

UIX.RenderApi/Microsoft/Iris/Input/Cursor.cs

@@ -0,0 +1,87 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Input.Cursor
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+namespace Microsoft.Iris.Input
+{
+    public class Cursor
+    {
+        public const int NoneResourceId = 1;
+        public const int MoveResourceId = 2;
+        public const int CopyResourceId = 3;
+        public static readonly Cursor Arrow = new Cursor(32512, CursorID.Arrow);
+        public static readonly Cursor AppStarting = new Cursor(32550, CursorID.AppStarting);
+        public static readonly Cursor Crosshair = new Cursor(32515, CursorID.Crosshair);
+        public static readonly Cursor Default = Arrow;
+        public static readonly Cursor Hand = new Cursor(32649, CursorID.Hand);
+        public static readonly Cursor Help = new Cursor(32651, CursorID.Help);
+        public static readonly Cursor IBeam = new Cursor(32513, CursorID.IBeam);
+        public static readonly Cursor No = new Cursor(32648, CursorID.No);
+        public static readonly Cursor Size = new Cursor(32646, CursorID.Size);
+        public static readonly Cursor SizeNS = new Cursor(32645, CursorID.SizeNS);
+        public static readonly Cursor SizeWE = new Cursor(32644, CursorID.SizeWE);
+        public static readonly Cursor SizeNWSE = new Cursor(32642, CursorID.SizeNWSE);
+        public static readonly Cursor SizeNESW = new Cursor(32643, CursorID.SizeNESW);
+        public static readonly Cursor WaitCursor = new Cursor(32514, CursorID.Wait);
+        public static readonly Cursor UpArrow = new Cursor(32516, CursorID.UpArrow);
+        public static readonly Cursor NullCursor = new Cursor(0, CursorID.None);
+        public static readonly Cursor Cancel = new Cursor(1, CursorID.Cancel);
+        public static readonly Cursor Move = new Cursor(2, CursorID.Move);
+        public static readonly Cursor Copy = new Cursor(3, CursorID.Copy);
+        private int m_idResource;
+        private CursorID m_idCursor;
+
+        public Cursor(int idResource, CursorID idCursor)
+        {
+            this.m_idResource = idResource;
+            this.m_idCursor = idCursor;
+        }
+
+        public int ResourceId => this.m_idResource;
+
+        public CursorID CursorID => this.m_idCursor;
+
+        public static Cursor GetCursor(CursorID cursor)
+        {
+            switch (cursor)
+            {
+                case CursorID.Arrow:
+                    return Arrow;
+                case CursorID.Cancel:
+                    return Cancel;
+                case CursorID.Copy:
+                    return Copy;
+                case CursorID.Crosshair:
+                    return Crosshair;
+                case CursorID.IBeam:
+                    return IBeam;
+                case CursorID.Hand:
+                    return Hand;
+                case CursorID.Move:
+                    return Move;
+                case CursorID.No:
+                    return No;
+                case CursorID.None:
+                    return NullCursor;
+                case CursorID.Size:
+                    return Size;
+                case CursorID.SizeNS:
+                    return SizeNS;
+                case CursorID.SizeWE:
+                    return SizeWE;
+                case CursorID.SizeNWSE:
+                    return SizeNWSE;
+                case CursorID.SizeNESW:
+                    return SizeNESW;
+                case CursorID.UpArrow:
+                    return UpArrow;
+                case CursorID.Wait:
+                    return WaitCursor;
+                default:
+                    return null;
+            }
+        }
+    }
+}

UIX.RenderApi/Microsoft/Iris/Input/CursorID.cs

@@ -0,0 +1,31 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Input.CursorID
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+namespace Microsoft.Iris.Input
+{
+    public enum CursorID
+    {
+        NotSpecified,
+        AppStarting,
+        Arrow,
+        Cancel,
+        Copy,
+        Crosshair,
+        IBeam,
+        Hand,
+        Help,
+        Move,
+        No,
+        None,
+        Size,
+        SizeNS,
+        SizeWE,
+        SizeNWSE,
+        SizeNESW,
+        UpArrow,
+        Wait,
+    }
+}

UIX.RenderApi/Microsoft/Iris/Input/IRawInputSite.cs

@@ -0,0 +1,13 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Input.IRawInputSite
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+namespace Microsoft.Iris.Input
+{
+    public interface IRawInputSite
+    {
+        object OwnerData { get; }
+    }
+}

UIX.RenderApi/Microsoft/Iris/Input/InputDeviceType.cs

@@ -0,0 +1,16 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Input.InputDeviceType
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+namespace Microsoft.Iris.Input
+{
+    public enum InputDeviceType
+    {
+        None,
+        Keyboard,
+        Mouse,
+        Other,
+    }
+}

UIX.RenderApi/Microsoft/Iris/Input/InputHandlerFlags.cs

@@ -0,0 +1,22 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Input.InputHandlerFlags
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+
+namespace Microsoft.Iris.Input
+{
+    [Flags]
+    public enum InputHandlerFlags
+    {
+        None = 0,
+        Keyboard = 1,
+        Mouse = 2,
+        Drag = 4,
+        Hid = 8,
+        AppCommand = 16, // 0x00000010
+        All = AppCommand | Hid | Drag | Mouse | Keyboard, // 0x0000001F
+    }
+}

UIX.RenderApi/Microsoft/Iris/Input/InputModifiers.cs

@@ -0,0 +1,29 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Input.InputModifiers
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+using System;
+
+namespace Microsoft.Iris.Input
+{
+    [Flags]
+    public enum InputModifiers
+    {
+        None = 0,
+        ControlKey = 1,
+        ShiftKey = 2,
+        AltKey = 4,
+        WindowsKey = 8,
+        LeftMouse = 16, // 0x00000010
+        RightMouse = 32, // 0x00000020
+        MiddleMouse = 64, // 0x00000040
+        XMouse1 = 128, // 0x00000080
+        XMouse2 = 256, // 0x00000100
+        DoubleClick = 512, // 0x00000200
+        AllKeys = WindowsKey | AltKey | ShiftKey | ControlKey, // 0x0000000F
+        AllButtons = XMouse2 | XMouse1 | MiddleMouse | RightMouse | LeftMouse, // 0x000001F0
+        AllMouse = AllButtons | DoubleClick, // 0x000003F0
+    }
+}

UIX.RenderApi/Microsoft/Iris/Input/KeyAction.cs

@@ -0,0 +1,16 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Input.KeyAction
+// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
+// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
+
+namespace Microsoft.Iris.Input
+{
+    public enum KeyAction
+    {
+        None,
+        Up,
+        Down,
+        Character,
+    }
+}