Added raw UIX.RenderApi project

UIX.RenderApi.Skia/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.Skia/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.Skia/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.Skia/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.Skia/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.Skia/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.Skia/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.Skia/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.Skia/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.Skia/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.Skia/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 : (object) 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((Array) this._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((Array) this._entries, 0, (Array) 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 = (object) null;
+          this._entries[index3].value = (object) 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 = (object) 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>((object) null, (object) 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>((object) null, (object) 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 = (object) 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 = (object) 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 = (object) 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 = (object) 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.Skia/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((Array) this._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((Array) this._entries, 0, (Array) 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((object) 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.Skia/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 = Cursor.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 Cursor.Arrow;
+        case CursorID.Cancel:
+          return Cursor.Cancel;
+        case CursorID.Copy:
+          return Cursor.Copy;
+        case CursorID.Crosshair:
+          return Cursor.Crosshair;
+        case CursorID.IBeam:
+          return Cursor.IBeam;
+        case CursorID.Hand:
+          return Cursor.Hand;
+        case CursorID.Move:
+          return Cursor.Move;
+        case CursorID.No:
+          return Cursor.No;
+        case CursorID.None:
+          return Cursor.NullCursor;
+        case CursorID.Size:
+          return Cursor.Size;
+        case CursorID.SizeNS:
+          return Cursor.SizeNS;
+        case CursorID.SizeWE:
+          return Cursor.SizeWE;
+        case CursorID.SizeNWSE:
+          return Cursor.SizeNWSE;
+        case CursorID.SizeNESW:
+          return Cursor.SizeNESW;
+        case CursorID.UpArrow:
+          return Cursor.UpArrow;
+        case CursorID.Wait:
+          return Cursor.WaitCursor;
+        default:
+          return (Cursor) null;
+      }
+    }
+  }
+}

UIX.RenderApi.Skia/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.Skia/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.Skia/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.Skia/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.Skia/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.Skia/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,
+  }
+}

UIX.RenderApi.Skia/Microsoft/Iris/Input/KeyboardMessageId.cs

@@ -0,0 +1,18 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Input.KeyboardMessageId
+// 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 KeyboardMessageId
+  {
+    Down,
+    Up,
+    Char,
+    SysDown,
+    SysUp,
+    SysChar,
+  }
+}