Add project files.

UIX/Microsoft/Iris/Session/DeferredCall.cs

@@ -0,0 +1,170 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.DeferredCall
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+using Microsoft.Iris.Queues;
+using Microsoft.Iris.Render;
+using System;
+using System.Threading;
+
+namespace Microsoft.Iris.Session
+{
+    public sealed class DeferredCall : QueueItem
+    {
+        private const int c_maxCacheCount = 100;
+        private DeferredCall.CallType _callType;
+        private Delegate _target;
+        private object _param;
+        private EventArgs _args;
+        private static DeferredCall s_cachedList = null;
+        private static int s_cachedCount = 0;
+        private static object s_cacheLock = new object();
+
+        private DeferredCall()
+        {
+        }
+
+        private static DeferredCall AllocateFromCache()
+        {
+            DeferredCall deferredCall = null;
+            lock (s_cacheLock)
+            {
+                if (s_cachedList != null)
+                {
+                    deferredCall = s_cachedList;
+                    s_cachedList = (DeferredCall)deferredCall._next;
+                    deferredCall._next = null;
+                    --s_cachedCount;
+                }
+            }
+            if (deferredCall == null)
+                deferredCall = new DeferredCall();
+            return deferredCall;
+        }
+
+        public static DeferredCall Create(SimpleCallback callback)
+        {
+            DeferredCall deferredCall = AllocateFromCache();
+            deferredCall._callType = CallType.Simple;
+            deferredCall._target = callback;
+            return deferredCall;
+        }
+
+        public static DeferredCall Create(DeferredHandler handler, object param)
+        {
+            DeferredCall deferredCall = AllocateFromCache();
+            deferredCall._callType = CallType.OneParam;
+            deferredCall._target = handler;
+            deferredCall._param = param;
+            return deferredCall;
+        }
+
+        public static DeferredCall Create(
+          EventHandler handler,
+          object sender,
+          EventArgs args)
+        {
+            DeferredCall deferredCall = AllocateFromCache();
+            deferredCall._callType = CallType.Event;
+            deferredCall._target = handler;
+            deferredCall._param = sender;
+            deferredCall._args = args;
+            return deferredCall;
+        }
+
+        public static DeferredCall Create(IDeferredInvokeItem item)
+        {
+            DeferredCall deferredCall = AllocateFromCache();
+            deferredCall._callType = CallType.RenderItem;
+            deferredCall._param = item;
+            return deferredCall;
+        }
+
+        public override void Dispatch()
+        {
+            switch (this._callType)
+            {
+                case CallType.Simple:
+                    ((SimpleCallback)this._target)();
+                    break;
+                case CallType.OneParam:
+                    ((DeferredHandler)this._target)(this._param);
+                    break;
+                case CallType.Event:
+                    ((EventHandler)this._target)(this._param, this._args);
+                    break;
+                case CallType.RenderItem:
+                    ((IDeferredInvokeItem)this._param).Dispatch();
+                    break;
+                default:
+                    throw new InvalidOperationException();
+            }
+            this._callType = CallType.None;
+            this._target = null;
+            this._param = null;
+            this._args = null;
+            this._prev = null;
+            this._next = null;
+            this._owner = null;
+            lock (s_cacheLock)
+            {
+                if (s_cachedCount >= 100)
+                    return;
+                this._next = s_cachedList;
+                s_cachedList = this;
+                ++s_cachedCount;
+            }
+        }
+
+        public static void Post(DispatchPriority priority, SimpleCallback callback)
+        {
+            QueueItem queueItem = Create(callback);
+            UIDispatcher.Post(priority, queueItem);
+        }
+
+        public static void Post(Thread thread, DispatchPriority priority, SimpleCallback callback)
+        {
+            QueueItem queueItem = Create(callback);
+            UIDispatcher.Post(thread, priority, queueItem);
+        }
+
+        public static void Post(DispatchPriority priority, DeferredHandler handler)
+        {
+            QueueItem queueItem = Create(handler, null);
+            UIDispatcher.Post(priority, queueItem);
+        }
+
+        public static void Post(DispatchPriority priority, DeferredHandler handler, object param)
+        {
+            QueueItem queueItem = Create(handler, param);
+            UIDispatcher.Post(priority, queueItem);
+        }
+
+        public static void Post(TimeSpan delay, DeferredHandler handler, object param)
+        {
+            QueueItem queueItem = Create(handler, param);
+            UIDispatcher.Post(delay, queueItem);
+        }
+
+        public static void Post(
+          Thread thread,
+          DispatchPriority priority,
+          DeferredHandler handler,
+          object param)
+        {
+            QueueItem queueItem = Create(handler, param);
+            UIDispatcher.Post(thread, priority, queueItem);
+        }
+
+        private enum CallType
+        {
+            None,
+            Simple,
+            OneParam,
+            Event,
+            RenderItem,
+        }
+    }
+}

UIX/Microsoft/Iris/Session/DeferredHandler.cs

@@ -0,0 +1,10 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.DeferredHandler
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public delegate void DeferredHandler(object args);
+}

UIX/Microsoft/Iris/Session/Direction.cs

@@ -0,0 +1,18 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.Direction
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public enum Direction
+    {
+        North,
+        South,
+        East,
+        West,
+        Previous,
+        Next,
+    }
+}

UIX/Microsoft/Iris/Session/DispatchPriority.cs

@@ -0,0 +1,30 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.DispatchPriority
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public enum DispatchPriority
+    {
+        Housekeeping,
+        AppEventHigh,
+        High,
+        AppEvent,
+        Normal,
+        RPC,
+        Input,
+        Script,
+        RepeatItem,
+        Layout,
+        LayoutPass2,
+        LayoutApply,
+        LayoutSync,
+        Render,
+        RenderSync,
+        Idle,
+        Sleep,
+        NumPriorities,
+    }
+}

UIX/Microsoft/Iris/Session/DispatcherTimer.cs

@@ -0,0 +1,220 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.DispatcherTimer
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+using Microsoft.Iris.Debug;
+using Microsoft.Iris.Markup;
+using Microsoft.Iris.Queues;
+using System;
+
+namespace Microsoft.Iris.Session
+{
+    public class DispatcherTimer
+    {
+        private TimeSpan _interval;
+        private bool _autoRepeat;
+        private object _userData;
+        private DispatcherTimer.TimerCallback _callback;
+        private long _timeBase;
+        private TimeoutManager _timeoutManager;
+        private ITimerOwner _owner;
+
+        public DispatcherTimer(ITimerOwner owner)
+        {
+            this._owner = owner;
+            this._interval = TimeSpan.FromMilliseconds(100.0);
+            this._autoRepeat = true;
+            this._timeBase = SystemTickCount.Milliseconds;
+            this._timeoutManager = UIDispatcher.CurrentDispatcher.TimeoutManager;
+        }
+
+        public DispatcherTimer()
+          : this(null)
+        {
+        }
+
+        public TimeSpan TimeSpanInterval
+        {
+            get => this._interval;
+            set
+            {
+                if (!(this._interval != value))
+                    return;
+                this._interval = value;
+                if (this.Enabled)
+                    this.Start();
+                this.FireNotification(NotificationID.Interval);
+            }
+        }
+
+        public int Interval
+        {
+            get => (int)this.TimeSpanInterval.TotalMilliseconds;
+            set => this.TimeSpanInterval = TimeSpan.FromMilliseconds(value);
+        }
+
+        public bool Enabled
+        {
+            get => this._callback != null;
+            set
+            {
+                if (this.Enabled == value)
+                    return;
+                if (value)
+                    this.Start();
+                else
+                    this.Stop();
+            }
+        }
+
+        public bool AutoRepeat
+        {
+            get => this._autoRepeat;
+            set
+            {
+                if (this._autoRepeat == value)
+                    return;
+                this._autoRepeat = value;
+                this.FireNotification(NotificationID.AutoRepeat);
+            }
+        }
+
+        public object UserData
+        {
+            get => this._userData;
+            set
+            {
+                if (this._userData == value)
+                    return;
+                this._userData = value;
+            }
+        }
+
+        public void Start()
+        {
+            bool enabled = this.Enabled;
+            this.StopWorker();
+            this._timeBase = SystemTickCount.Milliseconds;
+            this._callback = new DispatcherTimer.TimerCallback(this);
+            this.ScheduleCallback(this._timeBase);
+            this.FireEnabledChange(enabled);
+        }
+
+        public void Stop()
+        {
+            bool enabled = this.Enabled;
+            this.StopWorker();
+            this.FireEnabledChange(enabled);
+        }
+
+        private void StopWorker()
+        {
+            if (this._callback == null)
+                return;
+            this._timeoutManager.CancelTimeout(_callback);
+            this._callback = null;
+        }
+
+        private void FireEnabledChange(bool wasEnabled)
+        {
+            if (this.Enabled == wasEnabled)
+                return;
+            this.FireNotification(NotificationID.Enabled);
+        }
+
+        public override string ToString()
+        {
+            string str = " one-shot";
+            if (this._autoRepeat)
+                str = " repeating";
+            return "[" + Interval + str + "] -> " + DebugHelpers.DEBUG_ObjectToString(Tick);
+        }
+
+        public event EventHandler Tick;
+
+        private void ScheduleCallback(long currentTimeInMilliseconds)
+        {
+            if (this._callback == null)
+                return;
+            TimeSpan timeSpan1 = this._interval;
+            TimeSpan timeSpan2 = TimeSpan.FromMilliseconds(currentTimeInMilliseconds - this._timeBase);
+            if (timeSpan2 >= timeSpan1)
+            {
+                long ticks = timeSpan1.Ticks;
+                if (ticks > 0L)
+                    timeSpan1 = TimeSpan.FromTicks(ticks * ((timeSpan2.Ticks + ticks / 2L) / ticks));
+            }
+            this._timeBase += (long)timeSpan1.TotalMilliseconds;
+            this._timeoutManager.SetTimeoutRelative(_callback, TimeSpan.FromMilliseconds(this._timeBase - currentTimeInMilliseconds));
+        }
+
+        private void CallTickHandlers(DispatcherTimer.TimerCallback callback)
+        {
+            if (!this.CallbackValid(callback))
+                return;
+            if (this._autoRepeat)
+            {
+                this.ScheduleCallback(SystemTickCount.Milliseconds);
+            }
+            else
+            {
+                this._callback = null;
+                this.FireEnabledChange(true);
+            }
+            if (this.Tick != null)
+                this.Tick(this._owner != null ? _owner : (object)this, EventArgs.Empty);
+            this.FireNotification(NotificationID.Tick);
+        }
+
+        private bool CallbackValid(DispatcherTimer.TimerCallback callback) => callback == this._callback;
+
+        private void FireNotification(string id)
+        {
+            if (this._owner == null)
+                return;
+            this._owner.OnTimerPropertyChanged(id);
+        }
+
+        private class TimerCallback : QueueItem
+        {
+            private DispatcherTimer _timer;
+
+            public TimerCallback(DispatcherTimer timer) => this._timer = timer;
+
+            public override void Dispatch() => this._timer.CallTickHandlers(this);
+
+            public override string ToString()
+            {
+                string str = "";
+                if (!this._timer.CallbackValid(this))
+                    str = "CANCELED ";
+                return str + this.GetType().Name + " -> " + _timer;
+            }
+        }
+
+        public static class SystemTickCount
+        {
+            private static long s_tickCount;
+            private static int s_lastTickCount;
+
+            public static long Milliseconds
+            {
+                get
+                {
+                    Refresh();
+                    return s_tickCount;
+                }
+            }
+
+            private static void Refresh()
+            {
+                int tickCount = Environment.TickCount;
+                long num = tickCount < s_lastTickCount ? int.MaxValue - s_lastTickCount + tickCount : tickCount - s_lastTickCount;
+                s_tickCount += num;
+                s_lastTickCount = tickCount;
+            }
+        }
+    }
+}

UIX/Microsoft/Iris/Session/EffectManager.cs

@@ -0,0 +1,98 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.EffectManager
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+using Microsoft.Iris.Drawing;
+using Microsoft.Iris.Render;
+using System;
+
+namespace Microsoft.Iris.Session
+{
+    public class EffectManager : IDisposable
+    {
+        public const string ColorEffectProperty = "ColorElem.Color";
+        public const string ImageEffectProperty = "ImageElem.Image";
+        private const string s_colorElement = "ColorElem";
+        private const string s_imageElement = "ImageElem";
+        private IRenderSession _renderSession;
+        private bool _fDisposed;
+        private IEffectTemplate _effectTemplateColor;
+        private IEffectTemplate _effectTemplateImage;
+        private IEffectTemplate _effectTemplateImageWithColor;
+
+        public EffectManager(IRenderSession renderSession) => this._renderSession = renderSession;
+
+        public void Dispose() => this.Dispose(true);
+
+        private void Dispose(bool fDisposing)
+        {
+            if (!this._fDisposed && fDisposing)
+            {
+                if (this._effectTemplateColor != null)
+                {
+                    this._effectTemplateColor.UnregisterUsage(this);
+                    this._effectTemplateColor = null;
+                }
+                if (this._effectTemplateImage != null)
+                {
+                    this._effectTemplateImage.UnregisterUsage(this);
+                    this._effectTemplateImage = null;
+                }
+                if (this._effectTemplateImageWithColor != null)
+                {
+                    this._effectTemplateImageWithColor.UnregisterUsage(this);
+                    this._effectTemplateImageWithColor = null;
+                }
+                this._renderSession = null;
+            }
+            this._fDisposed = true;
+        }
+
+        public IEffectTemplate ColorEffectTemplate
+        {
+            get
+            {
+                if (this._effectTemplateColor == null)
+                {
+                    this._effectTemplateColor = this._renderSession.CreateEffectTemplate(this, "ColorEffect");
+                    ColorElement colorElement = new ColorElement("ColorElem");
+                    this._effectTemplateColor.AddEffectProperty("ColorElem.Color");
+                    this._effectTemplateColor.Build(colorElement);
+                }
+                return this._effectTemplateColor;
+            }
+        }
+
+        public IEffectTemplate ImageEffectTemplate
+        {
+            get
+            {
+                if (this._effectTemplateImage == null)
+                {
+                    this._effectTemplateImage = this._renderSession.CreateEffectTemplate(this, "ImageEffect");
+                    ImageElement imageElement = new ImageElement("ImageElem", null);
+                    this._effectTemplateImage.AddEffectProperty("ImageElem.Image");
+                    this._effectTemplateImage.Build(imageElement);
+                }
+                return this._effectTemplateImage;
+            }
+        }
+
+        public static IEffect CreateColorFillEffect(object oOwner, Color color)
+        {
+            IEffect instance = UISession.Default.EffectManager.ColorEffectTemplate.CreateInstance(oOwner);
+            instance.SetProperty("ColorElem.Color", color.RenderConvert());
+            return instance;
+        }
+
+        public static IEffect CreateBasicImageEffect(object oOwner, IImage renderImage)
+        {
+            IEffect instance = UISession.Default.EffectManager.ImageEffectTemplate.CreateInstance(oOwner);
+            if (renderImage != null)
+                instance.SetProperty("ImageElem.Image", renderImage);
+            return instance;
+        }
+    }
+}

UIX/Microsoft/Iris/Session/ErrorManager.cs

@@ -0,0 +1,306 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.ErrorManager
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+using Microsoft.Iris.Markup;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Microsoft.Iris.Session
+{
+    public static class ErrorManager
+    {
+        private static uint s_totalErrorsReported;
+        private static Stack<ErrorManager.Context> s_contextStack = new Stack<ErrorManager.Context>();
+        private static uint s_ignoringErrorsDepth;
+        private static bool s_errorBatchPending;
+        private static IList s_errors;
+        private static readonly SimpleCallback s_drainErrorQueueHandler = new SimpleCallback(OnDrainErrorQueue);
+
+        public static ErrorWatermark Watermark => new ErrorWatermark(s_totalErrorsReported);
+
+        public static void EnterContext(object contextObject) => EnterContext(contextObject, false);
+
+        public static void EnterContext(object contextObject, bool ignoreErrors) => EnterContext(new ErrorManager.Context(contextObject, ignoreErrors));
+
+        public static void EnterContext(IErrorContextSource contextSource) => EnterContext(new ErrorManager.Context(contextSource));
+
+        private static void EnterContext(ErrorManager.Context context)
+        {
+            if (context.IgnoreErrors)
+                ++s_ignoringErrorsDepth;
+            s_contextStack.Push(context);
+        }
+
+        public static string CurrentContext
+        {
+            get
+            {
+                string str = null;
+                if (s_contextStack.Count != 0)
+                    str = s_contextStack.Peek().ToString();
+                return str;
+            }
+        }
+
+        public static bool IgnoringErrors => s_ignoringErrorsDepth > 0U;
+
+        public static void ExitContext()
+        {
+            ErrorManager.Context context = s_contextStack.Peek();
+            if (context.IgnoreErrors)
+            {
+                s_totalErrorsReported = context.TotalErrorsOnEnter;
+                --s_ignoringErrorsDepth;
+            }
+            s_contextStack.Pop();
+        }
+
+        public static uint TotalErrorsReported => s_totalErrorsReported;
+
+        public static event NotifyErrorBatch OnErrors;
+
+        public static IList GetErrors()
+        {
+            IList errors = s_errors;
+            s_errors = null;
+            return errors;
+        }
+
+        public static void ReportError(string message) => TrackReportWorker(-1, -1, false, message);
+
+        public static void ReportError(string format, object param) => TrackReport(-1, -1, false, format, param);
+
+        public static void ReportError(string format, object param1, object param2) => TrackReport(-1, -1, false, format, param1, param2);
+
+        public static void ReportError(string format, object param1, object param2, object param3) => TrackReport(-1, -1, false, format, param1, param2, param3);
+
+        public static void ReportError(
+          string format,
+          object param1,
+          object param2,
+          object param3,
+          object param4)
+        {
+            TrackReport(-1, -1, false, format, param1, param2, param3, param4);
+        }
+
+        public static void ReportError(
+          string format,
+          object param1,
+          object param2,
+          object param3,
+          object param4,
+          object param5)
+        {
+            TrackReport(-1, -1, false, format, param1, param2, param3, param4, param5);
+        }
+
+        public static void ReportError(int line, int column, string message) => TrackReportWorker(line, column, false, message);
+
+        public static void ReportError(int line, int column, string format, object param) => TrackReport(line, column, false, format, param);
+
+        public static void ReportError(
+          int line,
+          int column,
+          string format,
+          object param1,
+          object param2)
+        {
+            TrackReport(line, column, false, format, param1, param2);
+        }
+
+        public static void ReportWarning(string message) => TrackReportWorker(-1, -1, true, message);
+
+        public static void ReportWarning(string format, object param) => TrackReport(-1, -1, true, format, param);
+
+        public static void ReportWarning(string format, object param1, object param2) => TrackReport(-1, -1, true, format, param1, param2);
+
+        public static void ReportWarning(int line, int column, string message) => TrackReportWorker(line, column, true, message);
+
+        public static void ReportWarning(int line, int column, string format, object param) => TrackReport(line, column, true, format, param);
+
+        private static void TrackReportWorker(int line, int column, bool warning, string message)
+        {
+            if (!IgnoringErrors)
+            {
+                string str = null;
+                if (s_contextStack.Count != 0)
+                {
+                    ErrorManager.Context context = s_contextStack.Peek();
+                    str = context.Description;
+                    if (line == -1 && column == -1)
+                        context.GetErrorPosition(ref line, ref column);
+                }
+                ErrorRecord errorRecord = new ErrorRecord();
+                errorRecord.Context = str;
+                errorRecord.Line = line;
+                errorRecord.Column = column;
+                errorRecord.Warning = warning;
+                errorRecord.Message = message;
+                if (s_errors == null)
+                    s_errors = new ArrayList();
+                s_errors.Add(errorRecord);
+                QueueNotify();
+            }
+            if (warning)
+                return;
+            ++s_totalErrorsReported;
+        }
+
+        public static void TrackReport(
+          int line,
+          int column,
+          bool warning,
+          string format,
+          object param)
+        {
+            string message = null;
+            if (!IgnoringErrors)
+                message = string.Format(format, param);
+            TrackReportWorker(line, column, warning, message);
+        }
+
+        public static void TrackReport(
+          int line,
+          int column,
+          bool warning,
+          string format,
+          object param1,
+          object param2)
+        {
+            string message = null;
+            if (!IgnoringErrors)
+                message = string.Format(format, param1, param2);
+            TrackReportWorker(line, column, warning, message);
+        }
+
+        public static void TrackReport(
+          int line,
+          int column,
+          bool warning,
+          string format,
+          object param1,
+          object param2,
+          object param3)
+        {
+            string message = null;
+            if (!IgnoringErrors)
+                message = string.Format(format, param1, param2, param3);
+            TrackReportWorker(line, column, warning, message);
+        }
+
+        public static void TrackReport(
+          int line,
+          int column,
+          bool warning,
+          string format,
+          object param1,
+          object param2,
+          object param3,
+          object param4)
+        {
+            string message = null;
+            if (!IgnoringErrors)
+                message = string.Format(format, param1, param2, param3, param4);
+            TrackReportWorker(line, column, warning, message);
+        }
+
+        public static void TrackReport(
+          int line,
+          int column,
+          bool warning,
+          string format,
+          object param1,
+          object param2,
+          object param3,
+          object param4,
+          object param5)
+        {
+            string message = null;
+            if (!IgnoringErrors)
+                message = string.Format(format, param1, param2, param3, param4, param5);
+            TrackReportWorker(line, column, warning, message);
+        }
+
+        private static void QueueNotify()
+        {
+            if (s_errorBatchPending)
+                return;
+            UIDispatcher currentDispatcher = UIDispatcher.CurrentDispatcher;
+            if (currentDispatcher != null && currentDispatcher.UISession != null)
+            {
+                s_errorBatchPending = true;
+                DeferredCall.Post(DispatchPriority.AppEventHigh, s_drainErrorQueueHandler);
+            }
+            else
+                OnDrainErrorQueue();
+        }
+
+        private static void OnDrainErrorQueue()
+        {
+            s_errorBatchPending = false;
+            IList errors = GetErrors();
+            if (OnErrors == null)
+                return;
+            OnErrors(errors);
+        }
+
+        public struct Context
+        {
+            private object _contextObject;
+            private bool _ignoreErrors;
+            private uint _errorCountOnEnter;
+            private IErrorContextSource _callback;
+
+            public Context(object contextObject, bool ignoreErrors)
+            {
+                this._contextObject = contextObject;
+                this._callback = null;
+                this._ignoreErrors = ignoreErrors;
+                this._errorCountOnEnter = s_totalErrorsReported;
+            }
+
+            public Context(IErrorContextSource contextSource)
+            {
+                this._callback = contextSource;
+                this._contextObject = null;
+                this._ignoreErrors = false;
+                this._errorCountOnEnter = s_totalErrorsReported;
+            }
+
+            public string Description
+            {
+                get
+                {
+                    string str = null;
+                    if (this._callback != null)
+                        str = this._callback.GetErrorContextDescription();
+                    else if (this._contextObject != null)
+                    {
+                        if (this._contextObject is string)
+                            str = (string)this._contextObject;
+                        else if (this._contextObject is TypeSchema)
+                            str = ((TypeSchema)this._contextObject).ErrorContextDescription;
+                    }
+                    return str;
+                }
+            }
+
+            public void GetErrorPosition(ref int line, ref int column)
+            {
+                if (this._callback == null)
+                    return;
+                this._callback.GetErrorPosition(ref line, ref column);
+            }
+
+            public bool IgnoreErrors => this._ignoreErrors;
+
+            public uint TotalErrorsOnEnter => this._errorCountOnEnter;
+
+            public override string ToString() => this._callback != null ? this._callback.ToString() : this.Description;
+        }
+    }
+}

UIX/Microsoft/Iris/Session/ErrorRecord.cs

@@ -0,0 +1,17 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.ErrorRecord
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public class ErrorRecord
+    {
+        public string Context;
+        public string Message;
+        public bool Warning;
+        public int Line;
+        public int Column;
+    }
+}

UIX/Microsoft/Iris/Session/ErrorWatermark.cs

@@ -0,0 +1,17 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.ErrorWatermark
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public struct ErrorWatermark
+    {
+        private uint _currentErrorCount;
+
+        public ErrorWatermark(uint currentErrorCount) => this._currentErrorCount = currentErrorCount;
+
+        public bool ErrorsDetected => (int)this._currentErrorCount != (int)ErrorManager.TotalErrorsReported;
+    }
+}

UIX/Microsoft/Iris/Session/EventRouteStages.cs

@@ -0,0 +1,22 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.EventRouteStages
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+using System;
+
+namespace Microsoft.Iris.Session
+{
+    [Flags]
+    public enum EventRouteStages
+    {
+        None = 0,
+        Preview = 1,
+        Direct = 2,
+        Bubbled = 4,
+        Routed = 8,
+        Unhandled = 16, // 0x00000010
+        All = Unhandled | Routed | Bubbled | Direct | Preview, // 0x0000001F
+    }
+}

UIX/Microsoft/Iris/Session/FormSessionConnectHandler.cs

@@ -0,0 +1,10 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.FormSessionConnectHandler
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public delegate void FormSessionConnectHandler(object sender, bool fIsConnected);
+}

UIX/Microsoft/Iris/Session/IErrorContextSource.cs

@@ -0,0 +1,15 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.IErrorContextSource
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public interface IErrorContextSource
+    {
+        string GetErrorContextDescription();
+
+        void GetErrorPosition(ref int line, ref int column);
+    }
+}

UIX/Microsoft/Iris/Session/IModalSession.cs

@@ -0,0 +1,13 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.IModalSession
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public interface IModalSession
+    {
+        bool IsModalAllowed { get; }
+    }
+}

UIX/Microsoft/Iris/Session/ITimerOwner.cs

@@ -0,0 +1,13 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.ITimerOwner
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public interface ITimerOwner
+    {
+        void OnTimerPropertyChanged(string id);
+    }
+}

UIX/Microsoft/Iris/Session/ITrackableUIElement.cs

@@ -0,0 +1,17 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.ITrackableUIElement
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+using Microsoft.Iris.Render;
+
+namespace Microsoft.Iris.Session
+{
+    public interface ITrackableUIElement
+    {
+        bool IsUIVisible { get; }
+
+        Rectangle EstimatePosition(IZoneDisplayChild ancestor);
+    }
+}

UIX/Microsoft/Iris/Session/ITrackableUIElementEvents.cs

@@ -0,0 +1,15 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.ITrackableUIElementEvents
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+using System;
+
+namespace Microsoft.Iris.Session
+{
+    public interface ITrackableUIElementEvents
+    {
+        event EventHandler UIChange;
+    }
+}

UIX/Microsoft/Iris/Session/IZoneDisplayChild.cs

@@ -0,0 +1,13 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.IZoneDisplayChild
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public interface IZoneDisplayChild
+    {
+        TransformSet Transforms { get; }
+    }
+}

UIX/Microsoft/Iris/Session/InputDeliveryStatus.cs

@@ -0,0 +1,14 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.InputDeliveryStatus
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+namespace Microsoft.Iris.Session
+{
+    public enum InputDeliveryStatus
+    {
+        Normal,
+        Truncated,
+    }
+}

UIX/Microsoft/Iris/Session/InputNotificationEventArgs.cs

@@ -0,0 +1,33 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Session.InputNotificationEventArgs
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+using Microsoft.Iris.Input;
+
+namespace Microsoft.Iris.Session
+{
+    public struct InputNotificationEventArgs
+    {
+        private EventRouteStages _handledStage;
+        private InputInfo _info;
+        private ICookedInputSite _target;
+
+        public InputNotificationEventArgs(
+          InputInfo info,
+          ICookedInputSite target,
+          EventRouteStages stage)
+        {
+            this._info = info;
+            this._target = target;
+            this._handledStage = stage;
+        }
+
+        public ICookedInputSite Target => this._target;
+
+        public InputInfo InputInfo => this._info;
+
+        public EventRouteStages HandledStage => this._handledStage;
+    }
+}