Namespace cleanup, move some categories out of UI namespace

src/CacheObject/IValues/InteractiveColor.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityExplorer.CacheObject;
+using UnityExplorer.UI;
+
+namespace UnityExplorer.CacheObject.IValues
+{
+    public class InteractiveColor : InteractiveValue
+    {
+        public bool IsValueColor32;
+
+        public Color EditedColor;
+
+        private Image m_colorImage;
+        private readonly InputFieldRef[] m_inputs = new InputFieldRef[4];
+        private readonly Slider[] m_sliders = new Slider[4];
+
+        private ButtonRef m_applyButton;
+
+        private static readonly string[] fieldNames = new[] { "R", "G", "B", "A" };
+
+        public override void OnBorrowed(CacheObjectBase owner)
+        {
+            base.OnBorrowed(owner);
+
+            m_applyButton.Component.gameObject.SetActive(owner.CanWrite);
+
+            foreach (var slider in m_sliders)
+                slider.interactable = owner.CanWrite;
+            foreach (var input in m_inputs)
+                input.Component.readOnly = !owner.CanWrite;
+        }
+
+        // owner setting value to this
+        public override void SetValue(object value)
+        {
+            OnOwnerSetValue(value);
+        }
+
+        private void OnOwnerSetValue(object value)
+        {
+            if (value is Color32 c32)
+            {
+                IsValueColor32 = true;
+                EditedColor = c32;
+                m_inputs[0].Text = c32.r.ToString();
+                m_inputs[1].Text = c32.g.ToString();
+                m_inputs[2].Text = c32.b.ToString();
+                m_inputs[3].Text = c32.a.ToString();
+                foreach (var slider in m_sliders)
+                    slider.maxValue = 255;
+            }
+            else
+            {
+                IsValueColor32 = false;
+                EditedColor = (Color)value;
+                m_inputs[0].Text = EditedColor.r.ToString();
+                m_inputs[1].Text = EditedColor.g.ToString();
+                m_inputs[2].Text = EditedColor.b.ToString();
+                m_inputs[3].Text = EditedColor.a.ToString();
+                foreach (var slider in m_sliders)
+                    slider.maxValue = 1;
+            }
+
+            if (m_colorImage)
+                m_colorImage.color = EditedColor;
+        }
+
+        // setting value to owner
+
+        public void SetValueToOwner()
+        {
+            if (IsValueColor32)
+                CurrentOwner.SetUserValue((Color32)EditedColor);
+            else
+                CurrentOwner.SetUserValue(EditedColor);
+        }
+
+        private void SetColorField(float val, int fieldIndex)
+        {
+            switch (fieldIndex)
+            {
+                case 0: EditedColor.r = val; break;
+                case 1: EditedColor.g = val; break;
+                case 2: EditedColor.b = val; break;
+                case 3: EditedColor.a = val; break;
+            }
+
+            if (m_colorImage)
+                m_colorImage.color = EditedColor;
+        }
+
+        private void OnInputChanged(string val, int fieldIndex)
+        {
+            try
+            {
+                float f;
+                if (IsValueColor32)
+                {
+                    byte value = byte.Parse(val);
+                    m_sliders[fieldIndex].value = value;
+                    f = (float)((decimal)value / 255);
+                }
+                else
+                {
+                    f = float.Parse(val);
+                    m_sliders[fieldIndex].value = f;
+                }
+
+                SetColorField(f, fieldIndex);
+            }
+            catch (ArgumentException) { } // ignore bad user input
+            catch (FormatException) { }
+            catch (OverflowException) { }
+            catch (Exception ex)
+            {
+                ExplorerCore.LogWarning("InteractiveColor OnInput: " + ex.ToString());
+            }
+        }
+
+        private void OnSliderValueChanged(float val, int fieldIndex)
+        {
+            try
+            {
+                if (IsValueColor32)
+                {
+                    m_inputs[fieldIndex].Text = ((byte)val).ToString();
+                    val /= 255f;
+                }
+                else
+                {
+                    m_inputs[fieldIndex].Text = val.ToString();
+                }
+
+                SetColorField(val, fieldIndex);
+            }
+            catch (Exception ex)
+            {
+                ExplorerCore.LogWarning("InteractiveColor OnSlider: " + ex.ToString());
+            }
+        }
+
+        // UI Construction
+
+        public override GameObject CreateContent(GameObject parent)
+        {
+            UIRoot = UIFactory.CreateVerticalGroup(parent, "InteractiveColor", false, false, true, true, 3, new Vector4(4, 4, 4, 4),
+                new Color(0.06f, 0.06f, 0.06f));
+
+            // hori group
+
+            var horiGroup = UIFactory.CreateHorizontalGroup(UIRoot, "ColorEditor", false, false, true, true, 5,
+                default, new Color(1, 1, 1, 0), TextAnchor.MiddleLeft);
+
+            // sliders / inputs
+
+            var grid = UIFactory.CreateGridGroup(horiGroup, "Grid", new Vector2(140, 25), new Vector2(2, 2), new Color(1, 1, 1, 0));
+            UIFactory.SetLayoutElement(grid, minWidth: 580, minHeight: 25, flexibleWidth: 0);
+
+            for (int i = 0; i < 4; i++)
+                AddEditorRow(i, grid);
+
+            // apply button
+
+            m_applyButton = UIFactory.CreateButton(horiGroup, "ApplyButton", "Apply", new Color(0.2f, 0.26f, 0.2f));
+            UIFactory.SetLayoutElement(m_applyButton.Component.gameObject, minHeight: 25, minWidth: 90);
+            m_applyButton.OnClick += SetValueToOwner;
+
+            // image of color
+
+            var imgObj = UIFactory.CreateUIObject("ColorImageHelper", horiGroup);
+            UIFactory.SetLayoutElement(imgObj, minHeight: 25, minWidth: 50, flexibleWidth: 50);
+            m_colorImage = imgObj.AddComponent<Image>();
+
+            return UIRoot;
+        }
+
+        internal void AddEditorRow(int index, GameObject groupObj)
+        {
+            var row = UIFactory.CreateHorizontalGroup(groupObj, "EditorRow_" + fieldNames[index],
+                false, true, true, true, 5, default, new Color(1, 1, 1, 0));
+
+            var label = UIFactory.CreateLabel(row, "RowLabel", $"{fieldNames[index]}:", TextAnchor.MiddleRight, Color.cyan);
+            UIFactory.SetLayoutElement(label.gameObject, minWidth: 17, flexibleWidth: 0, minHeight: 25);
+
+            var input = UIFactory.CreateInputField(row, "Input", "...");
+            UIFactory.SetLayoutElement(input.UIRoot, minWidth: 40, minHeight: 25, flexibleHeight: 0);
+            m_inputs[index] = input;
+            input.OnValueChanged += (string val) => { OnInputChanged(val, index); };
+
+            var sliderObj = UIFactory.CreateSlider(row, "Slider", out Slider slider);
+            m_sliders[index] = slider;
+            UIFactory.SetLayoutElement(sliderObj, minHeight: 25, minWidth: 70, flexibleWidth: 999, flexibleHeight: 0);
+            slider.minValue = 0;
+            slider.maxValue = 1;
+            slider.onValueChanged.AddListener((float val) => { OnSliderValueChanged(val, index); });
+        }
+    }
+}

src/CacheObject/IValues/InteractiveDictionary.cs

@@ -0,0 +1,250 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityExplorer.CacheObject;
+using UnityExplorer.CacheObject.Views;
+using UnityExplorer.Inspectors;
+using UnityExplorer.UI;
+using UnityExplorer.UI.Panels;
+using UnityExplorer.UI.Widgets;
+
+namespace UnityExplorer.CacheObject.IValues
+{
+    public class InteractiveDictionary : InteractiveValue, ICellPoolDataSource<CacheKeyValuePairCell>, ICacheObjectController
+    {
+        CacheObjectBase ICacheObjectController.ParentCacheObject => this.CurrentOwner;
+        object ICacheObjectController.Target => this.CurrentOwner.Value;
+        public Type TargetType { get; private set; }
+
+        public override bool CanWrite => base.CanWrite && RefIDictionary != null && !RefIDictionary.IsReadOnly;
+
+        public Type KeysType;
+        public Type ValuesType;
+        public IDictionary RefIDictionary;
+
+        public int ItemCount => cachedEntries.Count;
+        private readonly List<CacheKeyValuePair> cachedEntries = new List<CacheKeyValuePair>();
+
+        public ScrollPool<CacheKeyValuePairCell> DictScrollPool { get; private set; }
+
+        private Text NotSupportedLabel;
+
+        public Text TopLabel;
+
+        public LayoutElement KeyTitleLayout;
+        public LayoutElement ValueTitleLayout;
+
+        public override void OnBorrowed(CacheObjectBase owner)
+        {
+            base.OnBorrowed(owner);
+
+            DictScrollPool.Refresh(true, true);
+        }
+
+        public override void ReleaseFromOwner()
+        {
+            base.ReleaseFromOwner();
+
+            ClearAndRelease();
+        }
+
+        private void ClearAndRelease()
+        {
+            RefIDictionary = null;
+
+            foreach (var entry in cachedEntries)
+            {
+                entry.UnlinkFromView();
+                entry.ReleasePooledObjects();
+            }
+
+            cachedEntries.Clear();
+        }
+
+        public override void SetValue(object value)
+        {
+            if (value == null)
+            {
+                // should never be null
+                ClearAndRelease();
+                return;
+            }
+            else
+            {
+                var type = value.GetActualType();
+                ReflectionUtility.TryGetEntryTypes(type, out KeysType, out ValuesType);
+
+                CacheEntries(value);
+
+                TopLabel.text = $"[{cachedEntries.Count}] {SignatureHighlighter.Parse(type, false)}";
+            }
+
+            this.DictScrollPool.Refresh(true, false);
+        }
+
+        private void CacheEntries(object value)
+        {
+            RefIDictionary = value as IDictionary;
+
+            if (ReflectionUtility.TryGetDictEnumerator(value, out IEnumerator<DictionaryEntry> dictEnumerator))
+            {
+                NotSupportedLabel.gameObject.SetActive(false);
+
+                int idx = 0;
+                while (dictEnumerator.MoveNext())
+                {
+                    CacheKeyValuePair cache;
+                    if (idx >= cachedEntries.Count)
+                    {
+                        cache = new CacheKeyValuePair();
+                        cache.SetDictOwner(this, idx);
+                        cachedEntries.Add(cache);
+                    }
+                    else
+                        cache = cachedEntries[idx];
+
+                    cache.SetFallbackType(ValuesType);
+                    cache.SetKey(dictEnumerator.Current.Key);
+                    cache.SetValueFromSource(dictEnumerator.Current.Value);
+
+                    idx++;
+                }
+
+                // Remove excess cached entries if dict count decreased
+                if (cachedEntries.Count > idx)
+                {
+                    for (int i = cachedEntries.Count - 1; i >= idx; i--)
+                    {
+                        var cache = cachedEntries[i];
+                        if (cache.CellView != null)
+                            cache.UnlinkFromView();
+
+                        cache.ReleasePooledObjects();
+                        cachedEntries.RemoveAt(i);
+                    }
+                }
+            }
+            else
+            {
+                NotSupportedLabel.gameObject.SetActive(true);
+            }
+        }
+
+        // Setting value to dictionary
+
+        public void TrySetValueToKey(object key, object value, int keyIndex)
+        {
+            try
+            {
+                if (!RefIDictionary.Contains(key))
+                {
+                    ExplorerCore.LogWarning("Unable to set key! Key may have been boxed to/from Il2Cpp Object.");
+                    return;
+                }
+
+                RefIDictionary[key] = value;
+
+                var entry = cachedEntries[keyIndex];
+                entry.SetValueFromSource(value);
+                if (entry.CellView != null)
+                    entry.SetDataToCell(entry.CellView);
+            }
+            catch (Exception ex)
+            {
+                ExplorerCore.LogWarning($"Exception setting IDictionary key! {ex}");
+            }
+        }
+
+        // KVP entry scroll pool
+
+        public void OnCellBorrowed(CacheKeyValuePairCell cell) { }
+
+        public void SetCell(CacheKeyValuePairCell cell, int index)
+        {
+            CacheObjectControllerHelper.SetCell(cell, index, cachedEntries, SetCellLayout);
+        }
+
+        public int AdjustedWidth => (int)UIRect.rect.width - 80;
+        //public int AdjustedKeyWidth => HalfWidth - 50;
+
+        public override void SetLayout()
+        {
+            var minHeight = 5f;
+
+            KeyTitleLayout.minWidth = AdjustedWidth * 0.44f;
+            ValueTitleLayout.minWidth = AdjustedWidth * 0.55f;
+
+            foreach (var cell in DictScrollPool.CellPool)
+            {
+                SetCellLayout(cell);
+                if (cell.Enabled)
+                    minHeight += cell.Rect.rect.height;
+            }
+
+            this.scrollLayout.minHeight = Math.Min(InspectorPanel.CurrentPanelHeight - 400f, minHeight);
+        }
+
+        private void SetCellLayout(CacheObjectCell objcell)
+        {
+            var cell = objcell as CacheKeyValuePairCell;
+            cell.KeyGroupLayout.minWidth = cell.AdjustedWidth * 0.44f;
+            cell.RightGroupLayout.minWidth = cell.AdjustedWidth * 0.55f;
+
+            if (cell.Occupant?.IValue != null)
+                cell.Occupant.IValue.SetLayout();
+        }
+
+        private LayoutElement scrollLayout;
+        private RectTransform UIRect;
+
+        public override GameObject CreateContent(GameObject parent)
+        {
+            UIRoot = UIFactory.CreateVerticalGroup(parent, "InteractiveDict", true, true, true, true, 6, new Vector4(10, 3, 15, 4),
+                new Color(0.05f, 0.05f, 0.05f));
+            UIFactory.SetLayoutElement(UIRoot, flexibleWidth: 9999, minHeight: 25, flexibleHeight: 475);
+            UIRoot.AddComponent<ContentSizeFitter>().verticalFit = ContentSizeFitter.FitMode.PreferredSize;
+
+            UIRect = UIRoot.GetComponent<RectTransform>();
+
+            // Entries label
+
+            TopLabel = UIFactory.CreateLabel(UIRoot, "EntryLabel", "not set", TextAnchor.MiddleLeft, fontSize: 16);
+            TopLabel.horizontalOverflow = HorizontalWrapMode.Overflow;
+
+            // key / value titles
+
+            var titleGroup = UIFactory.CreateUIObject("TitleGroup", UIRoot);
+            UIFactory.SetLayoutElement(titleGroup, minHeight: 25, flexibleWidth: 9999, flexibleHeight: 0);
+            UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(titleGroup, false, true, true, true, padLeft: 65, padRight: 0, childAlignment: TextAnchor.LowerLeft);
+
+            var keyTitle = UIFactory.CreateLabel(titleGroup, "KeyTitle", "Keys", TextAnchor.MiddleLeft);
+            UIFactory.SetLayoutElement(keyTitle.gameObject, minWidth: 100, flexibleWidth: 0);
+            KeyTitleLayout = keyTitle.GetComponent<LayoutElement>();
+
+            var valueTitle = UIFactory.CreateLabel(titleGroup, "ValueTitle", "Values", TextAnchor.MiddleLeft);
+            UIFactory.SetLayoutElement(valueTitle.gameObject, minWidth: 100, flexibleWidth: 0);
+            ValueTitleLayout = valueTitle.GetComponent<LayoutElement>();
+
+            // entry scroll pool
+
+            DictScrollPool = UIFactory.CreateScrollPool<CacheKeyValuePairCell>(UIRoot, "EntryList", out GameObject scrollObj,
+                out GameObject _, new Color(0.09f, 0.09f, 0.09f));
+            UIFactory.SetLayoutElement(scrollObj, minHeight: 150, flexibleHeight: 0);
+            DictScrollPool.Initialize(this, SetLayout);
+            scrollLayout = scrollObj.GetComponent<LayoutElement>();
+
+            NotSupportedLabel = UIFactory.CreateLabel(DictScrollPool.Content.gameObject, "NotSupportedMessage",
+                "The IDictionary failed to enumerate. This is likely due to an issue with Unhollowed interfaces.",
+                TextAnchor.MiddleLeft, Color.red);
+
+            UIFactory.SetLayoutElement(NotSupportedLabel.gameObject, minHeight: 25, flexibleWidth: 9999);
+            NotSupportedLabel.gameObject.SetActive(false);
+
+            return UIRoot;
+        }
+    }
+}

src/CacheObject/IValues/InteractiveEnum.cs

@@ -0,0 +1,256 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityExplorer.CacheObject;
+using UnityExplorer.UI;
+
+namespace UnityExplorer.CacheObject.IValues
+{
+    public class InteractiveEnum : InteractiveValue
+    {
+        public bool IsFlags;
+        public Type EnumType;
+
+        private Type lastType;
+
+        public OrderedDictionary CurrentValues;
+
+        public CachedEnumValue ValueAtIdx(int idx) => (CachedEnumValue)CurrentValues[idx];
+        public CachedEnumValue ValueAtKey(object key) => (CachedEnumValue)CurrentValues[key];
+
+        private Dropdown enumDropdown;
+        private GameObject toggleHolder;
+        private readonly List<Toggle> flagToggles = new List<Toggle>();
+        private readonly List<Text> flagTexts = new List<Text>();
+
+        // Setting value from owner
+        public override void SetValue(object value)
+        {
+            EnumType = value.GetType();
+
+            if (lastType != EnumType)
+            {
+                CurrentValues = GetEnumValues(EnumType, out IsFlags);
+
+                if (IsFlags)
+                    SetupTogglesForEnumType();
+                else
+                    SetupDropdownForEnumType();
+
+                lastType = EnumType;
+            }
+
+            // setup ui for changes
+            if (IsFlags)
+                SetTogglesForValue(value);
+            else
+                SetDropdownForValue(value);
+        }
+
+        // Setting value to owner
+
+        private void OnApplyClicked()
+        {
+            if (IsFlags)
+                SetValueFromFlags();
+            else
+                SetValueFromDropdown();
+        }
+
+        private void SetValueFromDropdown()
+        {
+            try
+            {
+                CurrentOwner.SetUserValue(ValueAtIdx(enumDropdown.value).ActualValue);
+            }
+            catch (Exception ex)
+            {
+                ExplorerCore.LogWarning("Exception setting from dropdown: " + ex);
+            }
+        }
+
+        private void SetValueFromFlags()
+        {
+            try
+            {
+                List<string> values = new List<string>();
+                for (int i = 0; i < CurrentValues.Count; i++)
+                {
+                    if (flagToggles[i].isOn)
+                        values.Add(ValueAtIdx(i).Name);
+                }
+
+                CurrentOwner.SetUserValue(Enum.Parse(EnumType, string.Join(", ", values.ToArray())));
+            }
+            catch (Exception ex)
+            {
+                ExplorerCore.LogWarning("Exception setting from flag toggles: " + ex);
+            }
+        }
+
+        // setting UI state for value 
+
+        private void SetDropdownForValue(object value)
+        {
+            if (CurrentValues.Contains(value))
+            {
+                var cached = ValueAtKey(value);
+                enumDropdown.value = cached.EnumIndex;
+                enumDropdown.RefreshShownValue();
+            }
+            else
+                ExplorerCore.LogWarning("CurrentValues does not contain key '" + value?.ToString() ?? "<null>" + "'");
+        }
+
+        private void SetTogglesForValue(object value)
+        {
+            try
+            {
+                var split = value.ToString().Split(',');
+                var set = new HashSet<string>();
+                foreach (var s in split)
+                    set.Add(s.Trim());
+
+                for (int i = 0; i < CurrentValues.Count; i++)
+                    flagToggles[i].isOn = set.Contains(ValueAtIdx(i).Name);
+            }
+            catch (Exception ex)
+            {
+                ExplorerCore.LogWarning("Exception setting flag toggles: " + ex);
+            }
+        }
+
+        // Setting up the UI for the enum type when it changes or is first set
+
+        private void SetupDropdownForEnumType()
+        {
+            toggleHolder.SetActive(false);
+            enumDropdown.gameObject.SetActive(true);
+
+            // create dropdown entries
+            enumDropdown.options.Clear();
+
+            foreach (CachedEnumValue entry in CurrentValues.Values)
+                enumDropdown.options.Add(new Dropdown.OptionData(entry.Name));
+
+            enumDropdown.value = 0;
+            enumDropdown.RefreshShownValue();
+        }
+
+        private void SetupTogglesForEnumType()
+        {
+            toggleHolder.SetActive(true);
+            enumDropdown.gameObject.SetActive(false);
+
+            // create / set / hide toggles
+            for (int i = 0; i < CurrentValues.Count || i < flagToggles.Count; i++)
+            {
+                if (i >= CurrentValues.Count)
+                {
+                    if (i >= flagToggles.Count)
+                        break;
+
+                    flagToggles[i].gameObject.SetActive(false);
+                    continue;
+                }
+
+                if (i >= flagToggles.Count)
+                    AddToggleRow();
+
+                flagToggles[i].isOn = false;
+                flagTexts[i].text = ValueAtIdx(i).Name;
+            }
+        }
+
+        private void AddToggleRow()
+        {
+            var row = UIFactory.CreateUIObject("ToggleRow", toggleHolder);
+            UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(row, false, false, true, true, 2);
+            UIFactory.SetLayoutElement(row, minHeight: 25, flexibleWidth: 9999);
+
+            var toggleObj = UIFactory.CreateToggle(row, "ToggleObj", out Toggle toggle, out Text toggleText);
+            UIFactory.SetLayoutElement(toggleObj, minHeight: 25, flexibleWidth: 9999);
+
+            flagToggles.Add(toggle);
+            flagTexts.Add(toggleText);
+        }
+
+        // UI Construction
+
+        public override GameObject CreateContent(GameObject parent)
+        {
+            UIRoot = UIFactory.CreateVerticalGroup(parent, "InteractiveEnum", false, false, true, true, 3, new Vector4(4, 4, 4, 4),
+                new Color(0.06f, 0.06f, 0.06f));
+            UIFactory.SetLayoutElement(UIRoot, minHeight: 25, flexibleHeight: 9999, flexibleWidth: 9999);
+
+            var hori = UIFactory.CreateUIObject("Hori", UIRoot);
+            UIFactory.SetLayoutElement(hori, minHeight: 25, flexibleWidth: 9999);
+            UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(hori, false, false, true, true, 2);
+
+            var applyButton = UIFactory.CreateButton(hori, "ApplyButton", "Apply", new Color(0.2f, 0.27f, 0.2f));
+            UIFactory.SetLayoutElement(applyButton.Component.gameObject, minHeight: 25, minWidth: 100);
+            applyButton.OnClick += OnApplyClicked;
+
+            var dropdownObj = UIFactory.CreateDropdown(hori, out enumDropdown, "not set", 14, null);
+            UIFactory.SetLayoutElement(dropdownObj, minHeight: 25, flexibleWidth: 600);
+
+            toggleHolder = UIFactory.CreateUIObject("ToggleHolder", UIRoot);
+            UIFactory.SetLayoutGroup<VerticalLayoutGroup>(toggleHolder, false, false, true, true, 4);
+            UIFactory.SetLayoutElement(toggleHolder, minHeight: 25, flexibleWidth: 9999, flexibleHeight: 9999);
+
+            return UIRoot;
+        }
+
+
+        #region Enum cache 
+
+        public struct CachedEnumValue
+        {
+            public CachedEnumValue(object value, int index, string name)
+            {
+                EnumIndex = index;
+                Name = name;
+                ActualValue = value;
+            }
+
+            public readonly object ActualValue;
+            public int EnumIndex;
+            public readonly string Name;
+        }
+
+        internal static readonly Dictionary<string, OrderedDictionary> enumCache = new Dictionary<string, OrderedDictionary>();
+
+        internal static OrderedDictionary GetEnumValues(Type enumType, out bool isFlags)
+        {
+            isFlags = enumType.GetCustomAttributes(typeof(FlagsAttribute), true) is object[] fa && fa.Any();
+
+            if (!enumCache.ContainsKey(enumType.AssemblyQualifiedName))
+            {
+                var dict = new OrderedDictionary();
+                var addedNames = new HashSet<string>();
+
+                int i = 0;
+                foreach (var value in Enum.GetValues(enumType))
+                {
+                    var name = value.ToString();
+                    if (addedNames.Contains(name))
+                        continue;
+                    addedNames.Add(name);
+
+                    dict.Add(value, new CachedEnumValue(value, i, name));
+                    i++;
+                }
+
+                enumCache.Add(enumType.AssemblyQualifiedName, dict);
+            }
+
+            return enumCache[enumType.AssemblyQualifiedName];
+        }
+
+        #endregion
+    }
+}

src/CacheObject/IValues/InteractiveList.cs

@@ -0,0 +1,268 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityExplorer.CacheObject;
+using UnityExplorer.CacheObject.Views;
+using UnityExplorer.Inspectors;
+using UnityExplorer.UI;
+using UnityExplorer.UI.Panels;
+using UnityExplorer.UI.Widgets;
+
+namespace UnityExplorer.CacheObject.IValues
+{
+    public class InteractiveList : InteractiveValue, ICellPoolDataSource<CacheListEntryCell>, ICacheObjectController
+    {
+        CacheObjectBase ICacheObjectController.ParentCacheObject => this.CurrentOwner;
+        object ICacheObjectController.Target => this.CurrentOwner.Value;
+        public Type TargetType { get; private set; }
+
+        public override bool CanWrite => base.CanWrite && ((RefIList != null && !RefIList.IsReadOnly) || IsWritableGenericIList);
+
+        public Type EntryType;
+        public IList RefIList;
+
+        private bool IsWritableGenericIList;
+        private PropertyInfo genericIndexer;
+
+        public int ItemCount => cachedEntries.Count;
+        private readonly List<CacheListEntry> cachedEntries = new List<CacheListEntry>();
+
+        public ScrollPool<CacheListEntryCell> ListScrollPool { get; private set; }
+
+        public Text TopLabel;
+
+        public override void OnBorrowed(CacheObjectBase owner)
+        {
+            base.OnBorrowed(owner);
+
+            ListScrollPool.Refresh(true, true);
+        }
+
+        public override void ReleaseFromOwner()
+        {
+            base.ReleaseFromOwner();
+
+            ClearAndRelease();
+        }
+
+        private void ClearAndRelease()
+        {
+            RefIList = null;
+
+            foreach (var entry in cachedEntries)
+            {
+                entry.UnlinkFromView();
+                entry.ReleasePooledObjects();
+            }
+
+            cachedEntries.Clear();
+        }
+
+        // Setting the List value itself to this model
+        public override void SetValue(object value)
+        {
+            if (value == null)
+            {
+                // should never be null
+                if (cachedEntries.Any())
+                    ClearAndRelease();
+            }
+            else
+            {
+                var type = value.GetActualType();
+                ReflectionUtility.TryGetEntryType(type, out EntryType);
+
+                CacheEntries(value);
+
+                TopLabel.text = $"[{cachedEntries.Count}] {SignatureHighlighter.Parse(type, false)}";
+            }
+
+            //this.ScrollPoolLayout.minHeight = Math.Min(400f, 35f * values.Count);
+            this.ListScrollPool.Refresh(true, false);
+        }
+
+        private void CacheEntries(object value)
+        {
+            RefIList = value as IList;
+
+            // Check if the type implements IList<T> but not IList (ie. Il2CppArrayBase)
+            if (RefIList == null)
+                CheckGenericIList(value);
+            else
+                IsWritableGenericIList = false;
+
+            int idx = 0;
+
+            if (ReflectionUtility.TryGetEnumerator(value, out IEnumerator enumerator))
+            {
+                NotSupportedLabel.gameObject.SetActive(false);
+
+                while (enumerator.MoveNext())
+                {
+                    var entry = enumerator.Current;
+
+                    // If list count increased, create new cache entries
+                    CacheListEntry cache;
+                    if (idx >= cachedEntries.Count)
+                    {
+                        cache = new CacheListEntry();
+                        cache.SetListOwner(this, idx);
+                        cachedEntries.Add(cache);
+                    }
+                    else
+                        cache = cachedEntries[idx];
+
+                    cache.SetFallbackType(this.EntryType);
+                    cache.SetValueFromSource(entry);
+                    idx++;
+                }
+
+                // Remove excess cached entries if list count decreased
+                if (cachedEntries.Count > idx)
+                {
+                    for (int i = cachedEntries.Count - 1; i >= idx; i--)
+                    {
+                        var cache = cachedEntries[i];
+                        if (cache.CellView != null)
+                            cache.UnlinkFromView();
+
+                        cache.ReleasePooledObjects();
+                        cachedEntries.RemoveAt(i);
+                    }
+                }
+            }
+            else
+            {
+                NotSupportedLabel.gameObject.SetActive(true);
+            }
+        }
+
+        private void CheckGenericIList(object value)
+        {
+            try
+            {
+                var type = value.GetType();
+                if (type.GetInterfaces().Any(it => it.IsGenericType && it.GetGenericTypeDefinition() == typeof(IList<>)))
+                    IsWritableGenericIList = !(bool)type.GetProperty("IsReadOnly").GetValue(value, null);
+                else
+                    IsWritableGenericIList = false;
+
+                if (IsWritableGenericIList)
+                {
+                    // Find the "this[int index]" property.
+                    // It might be a private implementation.
+                    foreach (var prop in type.GetProperties(ReflectionUtility.FLAGS))
+                    {
+                        if ((prop.Name == "Item"
+                                || (prop.Name.StartsWith("System.Collections.Generic.IList<") && prop.Name.EndsWith(">.Item")))
+                            && prop.GetIndexParameters() is ParameterInfo[] parameters
+                            && parameters.Length == 1
+                            && parameters[0].ParameterType == typeof(int))
+                        {
+                            genericIndexer = prop;
+                            break;
+                        }
+                    }
+
+                    if (genericIndexer == null)
+                    {
+                        ExplorerCore.LogWarning($"Failed to find indexer property for IList<T> type '{type.FullName}'!");
+                        IsWritableGenericIList = false;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                ExplorerCore.LogWarning($"Exception processing IEnumerable for IList<T> check: {ex.ReflectionExToString()}");
+                IsWritableGenericIList = false;
+            }
+        }
+
+        // Setting the value of an index to the list
+
+        public void TrySetValueToIndex(object value, int index)
+        {
+            try
+            {
+                if (!IsWritableGenericIList)
+                {
+                    RefIList[index] = value;
+                }
+                else
+                {
+                    genericIndexer.SetValue(CurrentOwner.Value, value, new object[] { index });
+                }
+
+                var entry = cachedEntries[index];
+                entry.SetValueFromSource(value);
+
+                if (entry.CellView != null)
+                    entry.SetDataToCell(entry.CellView);
+            }
+            catch (Exception ex)
+            {
+                ExplorerCore.LogWarning($"Exception setting IList value: {ex}");
+            }
+        }
+
+        // List entry scroll pool
+
+        public override void SetLayout()
+        {
+            var minHeight = 5f;
+
+            foreach (var cell in ListScrollPool.CellPool)
+            {
+                if (cell.Enabled)
+                    minHeight += cell.Rect.rect.height;
+            }
+
+            this.scrollLayout.minHeight = Math.Min(InspectorPanel.CurrentPanelHeight - 400f, minHeight);
+        }
+
+        public void OnCellBorrowed(CacheListEntryCell cell) { } // not needed
+
+        public void SetCell(CacheListEntryCell cell, int index)
+        {
+            CacheObjectControllerHelper.SetCell(cell, index, cachedEntries, null);
+        }
+
+        private LayoutElement scrollLayout;
+
+        private Text NotSupportedLabel;
+
+        public override GameObject CreateContent(GameObject parent)
+        {
+            UIRoot = UIFactory.CreateVerticalGroup(parent, "InteractiveList", true, true, true, true, 6, new Vector4(10, 3, 15, 4),
+                new Color(0.05f, 0.05f, 0.05f));
+            UIFactory.SetLayoutElement(UIRoot, flexibleWidth: 9999, minHeight: 25, flexibleHeight: 600);
+            UIRoot.AddComponent<ContentSizeFitter>().verticalFit = ContentSizeFitter.FitMode.PreferredSize;
+
+            // Entries label
+
+            TopLabel = UIFactory.CreateLabel(UIRoot, "EntryLabel", "not set", TextAnchor.MiddleLeft, fontSize: 16);
+            TopLabel.horizontalOverflow = HorizontalWrapMode.Overflow;
+
+            // entry scroll pool
+
+            ListScrollPool = UIFactory.CreateScrollPool<CacheListEntryCell>(UIRoot, "EntryList", out GameObject scrollObj,
+                out GameObject _, new Color(0.09f, 0.09f, 0.09f));
+            UIFactory.SetLayoutElement(scrollObj, minHeight: 400, flexibleHeight: 0);
+            ListScrollPool.Initialize(this, SetLayout);
+            scrollLayout = scrollObj.GetComponent<LayoutElement>();
+
+            NotSupportedLabel = UIFactory.CreateLabel(ListScrollPool.Content.gameObject, "NotSupportedMessage",
+                "The IEnumerable failed to enumerate. This is likely due to an issue with Unhollowed interfaces.",
+                TextAnchor.MiddleLeft, Color.red);
+
+            UIFactory.SetLayoutElement(NotSupportedLabel.gameObject, minHeight: 25, flexibleWidth: 9999);
+            NotSupportedLabel.gameObject.SetActive(false);
+
+            return UIRoot;
+        }
+    }
+}

src/CacheObject/IValues/InteractiveString.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityExplorer.Core.Config;
+using UnityExplorer.CacheObject;
+using UnityExplorer.UI.Widgets;
+using UnityExplorer.UI;
+
+namespace UnityExplorer.CacheObject.IValues
+{
+    public class InteractiveString : InteractiveValue
+    {
+        private string RealValue;
+        public string EditedValue = "";
+
+        public InputFieldRef inputField;
+        public ButtonRef ApplyButton;
+
+        public GameObject SaveFileRow;
+        public InputFieldRef SaveFilePath;
+
+        public override void OnBorrowed(CacheObjectBase owner)
+        {
+            base.OnBorrowed(owner);
+
+            inputField.Component.readOnly = !owner.CanWrite;
+            ApplyButton.Component.gameObject.SetActive(owner.CanWrite);
+
+            SaveFilePath.Text = Path.Combine(ConfigManager.Default_Output_Path.Value, "untitled.txt");
+        }
+
+        private bool IsStringTooLong(string s)
+        {
+            if (s == null)
+                return false;
+
+            return s.Length >= UIManager.MAX_INPUTFIELD_CHARS;
+        }
+
+        public override void SetValue(object value)
+        {
+            RealValue = value as string;
+            SaveFileRow.SetActive(IsStringTooLong(RealValue));
+
+            if (value == null)
+            {
+                inputField.Text = "";
+                EditedValue = "";
+            }
+            else
+            {
+                EditedValue = (string)value;
+                inputField.Text = EditedValue;
+            }
+        }
+
+        private void OnApplyClicked()
+        {
+            CurrentOwner.SetUserValue(EditedValue);
+        }
+
+        private void OnInputChanged(string input)
+        {
+            EditedValue = input;
+            SaveFileRow.SetActive(IsStringTooLong(EditedValue));
+        }
+
+        private void OnSaveFileClicked()
+        {
+            if (RealValue == null)
+                return;
+
+            if (string.IsNullOrEmpty(SaveFilePath.Text))
+            {
+                ExplorerCore.LogWarning("Cannot save an empty file path!");
+                return;
+            }
+
+            var path = IOUtility.EnsureValidDirectory(SaveFilePath.Text);
+
+            if (File.Exists(path))
+                File.Delete(path);
+
+            File.WriteAllText(path, RealValue);
+        }
+
+        public override GameObject CreateContent(GameObject parent)
+        {
+            UIRoot = UIFactory.CreateVerticalGroup(parent, "InteractiveString", false, false, true, true, 3, new Vector4(4, 4, 4, 4),
+                new Color(0.06f, 0.06f, 0.06f));
+
+            // Save to file helper
+
+            SaveFileRow = UIFactory.CreateUIObject("SaveFileRow", UIRoot);
+            UIFactory.SetLayoutElement(SaveFileRow, flexibleWidth: 9999);
+            UIFactory.SetLayoutGroup<VerticalLayoutGroup>(SaveFileRow, false, true, true, true, 3);
+
+            UIFactory.CreateLabel(SaveFileRow, "Info", "<color=red>String is too long! Save to file if you want to see the full string.</color>",
+                TextAnchor.MiddleLeft);
+
+            var horizRow = UIFactory.CreateUIObject("Horiz", SaveFileRow);
+            UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(horizRow, false, false, true, true, 4);
+
+            var saveButton = UIFactory.CreateButton(horizRow, "SaveButton", "Save file");
+            UIFactory.SetLayoutElement(saveButton.Component.gameObject, minHeight: 25, minWidth: 100, flexibleWidth: 0);
+            saveButton.OnClick += OnSaveFileClicked;
+
+            SaveFilePath = UIFactory.CreateInputField(horizRow, "SaveInput", "...");
+            UIFactory.SetLayoutElement(SaveFilePath.UIRoot, minHeight: 25, flexibleWidth: 9999);
+
+            // Main Input / apply
+
+            ApplyButton = UIFactory.CreateButton(UIRoot, "ApplyButton", "Apply", new Color(0.2f, 0.27f, 0.2f));
+            UIFactory.SetLayoutElement(ApplyButton.Component.gameObject, minHeight: 25, minWidth: 100, flexibleWidth: 0);
+            ApplyButton.OnClick += OnApplyClicked;
+
+            inputField = UIFactory.CreateInputField(UIRoot, "InputField", "empty");
+            inputField.UIRoot.AddComponent<ContentSizeFitter>().verticalFit = ContentSizeFitter.FitMode.PreferredSize;
+            UIFactory.SetLayoutElement(inputField.UIRoot, minHeight: 25, flexibleHeight: 500, flexibleWidth: 9999);
+            inputField.Component.lineType = InputField.LineType.MultiLineNewline;
+            inputField.OnValueChanged += OnInputChanged;
+
+            return UIRoot;
+        }
+
+    }
+}

src/CacheObject/IValues/InteractiveValue.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityExplorer.CacheObject;
+using UnityExplorer.UI;
+using UnityExplorer.UI.Models;
+
+namespace UnityExplorer.CacheObject.IValues
+{
+    public abstract class InteractiveValue : IPooledObject
+    {
+        public static Type GetIValueTypeForState(ValueState state)
+        {
+            switch (state)
+            {
+                case ValueState.String:
+                    return typeof(InteractiveString);
+                case ValueState.Enum:
+                    return typeof(InteractiveEnum);
+                case ValueState.Collection:
+                    return typeof(InteractiveList);
+                case ValueState.Dictionary:
+                    return typeof(InteractiveDictionary);
+                case ValueState.ValueStruct:
+                    return typeof(InteractiveValueStruct);
+                case ValueState.Color:
+                    return typeof(InteractiveColor);
+                default: return null;
+            }
+        }
+
+        public GameObject UIRoot { get; set; }
+        public float DefaultHeight => -1f;
+
+        public virtual bool CanWrite => this.CurrentOwner.CanWrite;
+
+        public CacheObjectBase CurrentOwner => m_owner;
+        private CacheObjectBase m_owner;
+
+        public bool PendingValueWanted;
+
+        public virtual void OnBorrowed(CacheObjectBase owner)
+        {
+            if (this.m_owner != null)
+            {
+                ExplorerCore.LogWarning("Setting an IValue's owner but there is already one set. Maybe it wasn't cleaned up?");
+                ReleaseFromOwner();
+            }
+
+            this.m_owner = owner;
+        }
+
+        public virtual void ReleaseFromOwner()
+        {
+            if (this.m_owner == null)
+                return;
+
+            this.m_owner = null;
+        }
+
+        public abstract void SetValue(object value);
+
+        public virtual void SetLayout() { }
+
+        public abstract GameObject CreateContent(GameObject parent);
+    }
+}

src/CacheObject/IValues/InteractiveValueStruct.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityExplorer.CacheObject;
+using UnityExplorer.UI;
+
+namespace UnityExplorer.CacheObject.IValues
+{
+    public class InteractiveValueStruct : InteractiveValue
+    {
+        #region Struct cache / wrapper
+
+        public class StructInfo
+        {
+            public bool IsSupported;
+            public FieldInfo[] Fields;
+
+            public StructInfo(bool isSupported, FieldInfo[] fields)
+            {
+                IsSupported = isSupported;
+                Fields = fields;
+            }
+
+            public void SetValue(object instance, string input, int fieldIndex)
+            {
+                var field = Fields[fieldIndex];
+
+                object val;
+                if (field.FieldType == typeof(string))
+                    val = input;
+                else
+                {
+                    if (!ParseUtility.TryParse(input, field.FieldType, out val, out Exception ex))
+                    {
+                        ExplorerCore.LogWarning("Unable to parse input!");
+                        if (ex != null) ExplorerCore.Log(ex.ReflectionExToString());
+                        return;
+                    }
+                }
+
+                field.SetValue(instance, val);
+            }
+
+            public string GetValue(object instance, int fieldIndex)
+            {
+                var field = Fields[fieldIndex];
+                var value = field.GetValue(instance);
+                return ParseUtility.ToStringForInput(value, field.FieldType);
+            }
+        }
+
+        private static readonly Dictionary<string, StructInfo> typeSupportCache = new Dictionary<string, StructInfo>();
+
+        private const BindingFlags INSTANCE_FLAGS = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public;
+        private const string SYSTEM_VOID = "System.Void";
+
+        public static bool SupportsType(Type type)
+        {
+            if (!type.IsValueType || string.IsNullOrEmpty(type.AssemblyQualifiedName) || type.FullName == SYSTEM_VOID)
+                return false;
+
+            if (typeSupportCache.TryGetValue(type.AssemblyQualifiedName, out var info))
+                return info.IsSupported;
+
+            var supported = false;
+
+            var fields = type.GetFields(INSTANCE_FLAGS);
+            if (fields.Length > 0)
+            {
+                if (fields.Any(it => !ParseUtility.CanParse(it.FieldType)))
+                {
+                    supported = false;
+                    info = new StructInfo(supported, null);
+                }
+                else
+                {
+                    supported = true;
+                    info = new StructInfo(supported, fields);
+                }
+            }
+
+            typeSupportCache.Add(type.AssemblyQualifiedName, info);
+
+            return supported;
+        }
+
+        #endregion
+
+        public object RefInstance;
+
+        public StructInfo CurrentInfo;
+        private Type lastStructType;
+
+        private ButtonRef applyButton;
+        private readonly List<GameObject> fieldRows = new List<GameObject>();
+        private readonly List<InputFieldRef> inputFields = new List<InputFieldRef>();
+        private readonly List<Text> labels = new List<Text>();
+
+        public override void OnBorrowed(CacheObjectBase owner)
+        {
+            base.OnBorrowed(owner);
+
+            applyButton.Component.gameObject.SetActive(owner.CanWrite);
+        }
+
+        // Setting value from owner to this
+
+        public override void SetValue(object value)
+        {
+            RefInstance = value;
+
+            var type = RefInstance.GetType();
+
+            if (type != lastStructType)
+            {
+                CurrentInfo = typeSupportCache[type.AssemblyQualifiedName];
+                SetupUIForType();
+                lastStructType = type;
+            }
+
+            for (int i = 0; i < CurrentInfo.Fields.Length; i++)
+            {
+                inputFields[i].Text = CurrentInfo.GetValue(RefInstance, i);
+            }
+        }
+
+        private void OnApplyClicked()
+        {
+            try
+            {
+                for (int i = 0; i < CurrentInfo.Fields.Length; i++)
+                {
+                    CurrentInfo.SetValue(RefInstance, inputFields[i].Text, i);
+                }
+
+                CurrentOwner.SetUserValue(RefInstance);
+            }
+            catch (Exception ex)
+            {
+                ExplorerCore.LogWarning("Exception setting value: " + ex);
+            }
+        }
+
+        // UI Setup for type
+
+        private void SetupUIForType()
+        {
+            for (int i = 0; i < CurrentInfo.Fields.Length || i <= inputFields.Count; i++)
+            {
+                if (i >= CurrentInfo.Fields.Length)
+                {
+                    if (i >= inputFields.Count)
+                        break;
+
+                    fieldRows[i].SetActive(false);
+                    continue;
+                }
+
+                if (i >= inputFields.Count)
+                    AddEditorRow();
+
+                fieldRows[i].SetActive(true);
+
+                string label = SignatureHighlighter.Parse(CurrentInfo.Fields[i].FieldType, false);
+                label += $" <color={SignatureHighlighter.FIELD_INSTANCE}>{CurrentInfo.Fields[i].Name}</color>:";
+                labels[i].text = label;
+            }
+        }
+
+        private void AddEditorRow()
+        {
+            var row = UIFactory.CreateUIObject("HoriGroup", UIRoot);
+            //row.AddComponent<ContentSizeFitter>().horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
+            UIFactory.SetLayoutElement(row, minHeight: 25, flexibleWidth: 9999);
+            UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(row, false, false, true, true, 8, childAlignment: TextAnchor.MiddleLeft);
+
+            fieldRows.Add(row);
+
+            var label = UIFactory.CreateLabel(row, "Label", "notset", TextAnchor.MiddleLeft);
+            UIFactory.SetLayoutElement(label.gameObject, minHeight: 25, minWidth: 50, flexibleWidth: 0);
+            label.horizontalOverflow = HorizontalWrapMode.Wrap;
+            labels.Add(label);
+
+            var input = UIFactory.CreateInputField(row, "InputField", "...");
+            UIFactory.SetLayoutElement(input.UIRoot, minHeight: 25, minWidth: 200);
+            var fitter = input.UIRoot.AddComponent<ContentSizeFitter>();
+            fitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
+            fitter.horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
+            input.Component.lineType = InputField.LineType.MultiLineNewline;
+            inputFields.Add(input);
+        }
+
+        // UI Construction
+
+        public override GameObject CreateContent(GameObject parent)
+        {
+            UIRoot = UIFactory.CreateVerticalGroup(parent, "InteractiveValueStruct", false, false, true, true, 3, new Vector4(4, 4, 4, 4),
+                new Color(0.06f, 0.06f, 0.06f), TextAnchor.MiddleLeft);
+            UIFactory.SetLayoutElement(UIRoot, minHeight: 25, flexibleWidth: 9999);
+
+            applyButton = UIFactory.CreateButton(UIRoot, "ApplyButton", "Apply", new Color(0.2f, 0.27f, 0.2f));
+            UIFactory.SetLayoutElement(applyButton.Component.gameObject, minHeight: 25, minWidth: 175);
+            applyButton.OnClick += OnApplyClicked;
+
+            return UIRoot;
+        }
+    }
+}