Add project files.

2026-07-27 13:13:29 -07:00 · 2022-03-03 08:14:05 -06:00
parent cfa6f93211
commit 1198cc8a66
967 changed files with 118389 additions and 0 deletions
@@ -0,0 +1,342 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Choice
+// 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.Library;
+using Microsoft.Iris.Markup;
+using Microsoft.Iris.ModelItems;
+using System;
+using System.Collections;
+using System.ComponentModel;
+
+namespace Microsoft.Iris
+{
+    public class Choice :
+      ModelItem,
+      IValueRange,
+      IModelItem,
+      INotifyPropertyChanged,
+      IModelItemOwner,
+      IUIChoice,
+      IUIValueRange,
+      IDisposableObject,
+      INotifyObject,
+      AssemblyObjectProxyHelper.IFrameworkProxyObject,
+      AssemblyObjectProxyHelper.IAssemblyProxyObject
+    {
+        private NotifyService _notifier = new NotifyService();
+        private static readonly EventCookie s_chosenChangedEvent = EventCookie.ReserveSlot();
+        private Microsoft.Iris.ModelItems.Choice _choice;
+        private CodeListeners _listeners;
+        private ModelItem _lastChosen;
+
+        public Choice(IModelItemOwner owner, string description, IList options)
+          : base(owner, description)
+        {
+            Initialize();
+            Options = options;
+        }
+
+        public Choice(IModelItemOwner owner, string description)
+          : base(owner, description)
+          => Initialize();
+
+        public Choice(IModelItemOwner owner)
+          : this(owner, null)
+        {
+        }
+
+        public Choice()
+          : this(null)
+        {
+        }
+
+        protected override void OnDispose(bool disposing)
+        {
+            base.OnDispose(disposing);
+            if (disposing)
+            {
+                _notifier.ClearListeners();
+                _choice.Dispose(this);
+                _listeners.Dispose(this);
+            }
+            _choice = null;
+        }
+
+        object AssemblyObjectProxyHelper.IFrameworkProxyObject.FrameworkObject => this;
+
+        object AssemblyObjectProxyHelper.IAssemblyProxyObject.AssemblyObject => this;
+
+        public IList Options
+        {
+            get
+            {
+                using (ThreadValidator)
+                    return (IList)AssemblyLoadResult.UnwrapObject(_choice.Options);
+            }
+            set
+            {
+                using (ThreadValidator)
+                {
+                    IList potentialOptionsWrapped = (IList)AssemblyLoadResult.WrapObject(value);
+                    ValidateOptionsList(potentialOptionsWrapped, value);
+                    _choice.Options = potentialOptionsWrapped;
+                }
+            }
+        }
+
+        public object ChosenValue
+        {
+            get
+            {
+                using (ThreadValidator)
+                    return AssemblyLoadResult.UnwrapObject(_choice.ChosenValue);
+            }
+            set
+            {
+                using (ThreadValidator)
+                {
+                    int index;
+                    string error;
+                    if (!_choice.ValidateOption(AssemblyLoadResult.WrapObject(value), out index, out error))
+                        throw new ArgumentException(error);
+                    _choice.ChosenIndex = index;
+                }
+            }
+        }
+
+        public int ChosenIndex
+        {
+            get
+            {
+                using (ThreadValidator)
+                    return _choice.ChosenIndex;
+            }
+            set
+            {
+                using (ThreadValidator)
+                {
+                    string error;
+                    _choice.ChosenIndex = _choice.ValidateIndex(value, out error) ? value : throw new ArgumentException(error);
+                }
+            }
+        }
+
+        public int DefaultIndex
+        {
+            get
+            {
+                using (ThreadValidator)
+                    return _choice.DefaultIndex;
+            }
+            set
+            {
+                using (ThreadValidator)
+                    _choice.DefaultIndex = value;
+            }
+        }
+
+        object IValueRange.Value
+        {
+            get
+            {
+                using (ThreadValidator)
+                    return AssemblyLoadResult.UnwrapObject(((IUIValueRange)_choice).ObjectValue);
+            }
+        }
+
+        object IUIValueRange.ObjectValue => ((IUIValueRange)_choice).ObjectValue;
+
+        IList IUIChoice.Options
+        {
+            get => _choice.Options;
+            set => _choice.Options = value;
+        }
+
+        object IUIChoice.ChosenValue => _choice.ChosenValue;
+
+        bool IUIChoice.ValidateIndex(int index, out string error) => _choice.ValidateIndex(index, out error);
+
+        bool IUIChoice.ValidateOption(object value, out int index, out string error) => _choice.ValidateOption(value, out index, out error);
+
+        bool IUIChoice.ValidateOptionsList(IList value, out string error) => _choice.ValidateOptionsList(value, out error);
+
+        public bool HasNextValue
+        {
+            get
+            {
+                using (ThreadValidator)
+                    return _choice.HasNextValue;
+            }
+        }
+
+        public bool HasSelection
+        {
+            get
+            {
+                using (ThreadValidator)
+                    return _choice.HasSelection;
+            }
+        }
+
+        public bool HasPreviousValue
+        {
+            get
+            {
+                using (ThreadValidator)
+                    return _choice.HasPreviousValue;
+            }
+        }
+
+        public bool Wrap
+        {
+            get
+            {
+                using (ThreadValidator)
+                    return _choice.Wrap;
+            }
+            set
+            {
+                using (ThreadValidator)
+                    _choice.Wrap = value;
+            }
+        }
+
+        public void PreviousValue()
+        {
+            using (ThreadValidator)
+                _choice.PreviousValue();
+        }
+
+        public void PreviousValue(bool wrap)
+        {
+            using (ThreadValidator)
+                _choice.PreviousValue(wrap);
+        }
+
+        public void NextValue()
+        {
+            using (ThreadValidator)
+                _choice.NextValue();
+        }
+
+        public void NextValue(bool wrap)
+        {
+            using (ThreadValidator)
+                _choice.NextValue(wrap);
+        }
+
+        public void Clear()
+        {
+            using (ThreadValidator)
+                _choice.Clear();
+        }
+
+        public void DefaultValue()
+        {
+            using (ThreadValidator)
+                _choice.DefaultValue();
+        }
+
+        protected virtual void OnChosenChanged()
+        {
+        }
+
+        public event EventHandler ChosenChanged
+        {
+            add
+            {
+                using (ThreadValidator)
+                    AddEventHandler(s_chosenChangedEvent, value);
+            }
+            remove
+            {
+                using (ThreadValidator)
+                    RemoveEventHandler(s_chosenChangedEvent, value);
+            }
+        }
+
+        private void Initialize()
+        {
+            _choice = CreateInternalChoice();
+            _choice.DeclareOwner(this);
+            Vector<Listener> listeners = new Vector<Listener>(9);
+            DelegateListener.OnNotifyCallback callback = new DelegateListener.OnNotifyCallback(OnInternalChoicePropertyChanged);
+            listeners.Add(new DelegateListener(_choice, NotificationID.Options, callback));
+            listeners.Add(new DelegateListener(_choice, NotificationID.DefaultIndex, callback));
+            listeners.Add(new DelegateListener(_choice, NotificationID.ChosenIndex, callback));
+            listeners.Add(new DelegateListener(_choice, NotificationID.ChosenValue, new DelegateListener.OnNotifyCallback(OnChosenValueChanged)));
+            listeners.Add(new DelegateListener(_choice, NotificationID.Value, callback));
+            listeners.Add(new DelegateListener(_choice, NotificationID.HasSelection, callback));
+            listeners.Add(new DelegateListener(_choice, NotificationID.Wrap, callback));
+            listeners.Add(new DelegateListener(_choice, NotificationID.HasPreviousValue, callback));
+            listeners.Add(new DelegateListener(_choice, NotificationID.HasNextValue, callback));
+            _listeners = new CodeListeners(listeners);
+            _listeners.DeclareOwner(this);
+        }
+
+        protected override void OnPropertyChanged(string property)
+        {
+            base.OnPropertyChanged(property);
+            _notifier.FireThreadSafe(property);
+        }
+
+        private void OnInternalChoicePropertyChanged(DelegateListener listener) => FirePropertyChanged(listener.Watch);
+
+        private void OnChosenValueChanged(DelegateListener listener)
+        {
+            if (_lastChosen != null)
+                _lastChosen.Selected = false;
+            _lastChosen = ChosenValue as ModelItem;
+            if (_lastChosen != null)
+                _lastChosen.Selected = true;
+            FireChangedChosenEvent();
+            OnInternalChoicePropertyChanged(listener);
+        }
+
+        internal virtual Microsoft.Iris.ModelItems.Choice CreateInternalChoice() => new Microsoft.Iris.ModelItems.Choice();
+
+        private void ValidateOptionsList(IList potentialOptionsWrapped, IList potentialOptions)
+        {
+            using (ThreadValidator)
+            {
+                string error;
+                if (!_choice.ValidateOptionsList(potentialOptionsWrapped, out error))
+                    throw new ArgumentException(error);
+                ValidateOptionsListWorker(potentialOptions);
+            }
+        }
+
+        protected virtual void ValidateOptionsListWorker(IList potentialOptions)
+        {
+        }
+
+        private void FireChangedChosenEvent()
+        {
+            if (GetEventHandler(s_chosenChangedEvent) is EventHandler eventHandler)
+                eventHandler(this, EventArgs.Empty);
+            OnChosenChanged();
+        }
+
+        private void SetChosenSelected(bool selectedFlag)
+        {
+            if (!(ChosenValue is ModelItem chosenValue))
+                return;
+            chosenValue.Selected = selectedFlag;
+        }
+
+        void IDisposableObject.DeclareOwner(object owner)
+        {
+        }
+
+        void IDisposableObject.TransferOwnership(object owner)
+        {
+        }
+
+        void IDisposableObject.Dispose(object owner) => Dispose();
+
+        void INotifyObject.AddListener(Listener listener) => _notifier.AddListener(listener);
+    }
+}