// ~~~~~~~~~~~ Add Hooks window ~~~~~~~~~~~ public void OnClassSelectedForHooks(string typeFullName) { var type = ReflectionUtility.GetTypeByName(typeFullName); if (type == null) { ExplorerCore.LogWarning($"Could not find any type by name {typeFullName}!"); return; } Panel.SetAddHooksLabelType(SignatureHighlighter.Parse(type, true)); Panel.ResetMethodFilter(); filteredEligableMethods.Clear(); currentAddEligableMethods.Clear(); foreach (var method in type.GetMethods(ReflectionUtility.FLAGS)) { if (method.IsGenericMethod || UERuntimeHelper.IsBlacklisted(method)) { continue; } currentAddEligableMethods.Add(method); filteredEligableMethods.Add(method); } isAddingMethods = true; Panel.SetPage(HookManagerPanel.Pages.ClassMethodSelector); Panel.AddHooksScrollPool.Refresh(true, true); }
// 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; } }
public override void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member) { Type ctorReturnType; // if is parameterless struct ctor if (typeForStructConstructor != null) { ctorReturnType = typeForStructConstructor; this.Owner = inspector; // eg. Vector3.Vector3() this.NameLabelText = SignatureHighlighter.Parse(typeForStructConstructor, false); NameLabelText += $".{NameLabelText}()"; this.NameForFiltering = SignatureHighlighter.RemoveHighlighting(NameLabelText); this.NameLabelTextRaw = NameForFiltering; return; } else { base.SetInspectorOwner(inspector, member); Arguments = CtorInfo.GetParameters(); ctorReturnType = CtorInfo.DeclaringType; } if (ctorReturnType.IsGenericTypeDefinition) { GenericArguments = ctorReturnType.GetGenericArguments(); } }
private void SetGenericRows() { for (int i = 0; i < genericArguments.Length || i < genericArgRows.Count; i++) { if (i >= genericArguments.Length) { if (i >= genericArgRows.Count) { break; } else { // exceeded actual args, but still iterating so there must be views left, disable them genericArgRows[i].SetActive(false); } continue; } var arg = genericArguments[i]; if (i >= genericArgRows.Count) { AddArgRow(i, true); } genericArgRows[i].SetActive(true); var autoCompleter = genericAutocompleters[i]; autoCompleter.BaseType = arg; autoCompleter.CacheTypes(); var constraints = arg.GetGenericParameterConstraints(); autoCompleter.GenericConstraints = constraints; var sb = new StringBuilder($"<color={SignatureHighlighter.CONST}>{arg.Name}</color>"); for (int j = 0; j < constraints.Length; j++) { if (j == 0) { sb.Append(' ').Append('('); } else { sb.Append(',').Append(' '); } sb.Append(SignatureHighlighter.Parse(constraints[j], false)); if (j + 1 == constraints.Length) { sb.Append(')'); } } genericArgLabels[i].text = sb.ToString(); } }
// Setting target private void SetTarget(object target) { string prefix; if (StaticOnly) { Target = null; TargetType = target as Type; prefix = "[S]"; } else { TargetType = target.GetActualType(); prefix = "[R]"; } // Setup main labels and tab text currentBaseTabText = $"{prefix} {SignatureHighlighter.Parse(TargetType, false)}"; Tab.TabText.text = currentBaseTabText; NameText.text = SignatureHighlighter.Parse(TargetType, true); string asmText; if (TargetType.Assembly is AssemblyBuilder || string.IsNullOrEmpty(TargetType.Assembly.Location)) { asmText = $"{TargetType.Assembly.GetName().Name} <color=grey><i>(in memory)</i></color>"; } else { asmText = Path.GetFileName(TargetType.Assembly.Location); } AssemblyText.text = $"<color=grey>Assembly:</color> {asmText}"; // unity helpers SetUnityTargets(); // Get cache members this.members = CacheMember.GetCacheMembers(Target, TargetType, this); // reset filters this.filterInputField.Text = ""; SetFilter("", StaticOnly ? BindingFlags.Static : BindingFlags.Instance); scopeFilterButtons[BindingFlags.Default].Component.gameObject.SetActive(!StaticOnly); scopeFilterButtons[BindingFlags.Instance].Component.gameObject.SetActive(!StaticOnly); foreach (var toggle in memberTypeToggles) { toggle.isOn = true; } refreshWanted = true; }
protected virtual void SetValueState(CacheObjectCell cell, ValueStateArgs args) { // main value label if (args.valueActive) { cell.ValueLabel.text = ValueLabelText; cell.ValueLabel.supportRichText = args.valueRichText; cell.ValueLabel.color = args.valueColor; } else { cell.ValueLabel.text = ""; } // Type label (for primitives) cell.TypeLabel.gameObject.SetActive(args.typeLabelActive); if (args.typeLabelActive) { cell.TypeLabel.text = SignatureHighlighter.Parse(LastValueType, false); } // toggle for bools cell.Toggle.gameObject.SetActive(args.toggleActive); if (args.toggleActive) { cell.Toggle.interactable = CanWrite; cell.Toggle.isOn = (bool)Value; cell.ToggleText.text = Value.ToString(); } // inputfield for numbers cell.InputField.UIRoot.SetActive(args.inputActive); if (args.inputActive) { cell.InputField.Text = ParseUtility.ToStringForInput(Value, LastValueType); cell.InputField.Component.readOnly = !CanWrite; } // apply for bool and numbers cell.ApplyButton.Component.gameObject.SetActive(args.applyActive); // Inspect button only if last value not null. if (cell.InspectButton != null) { cell.InspectButton.Component.gameObject.SetActive(args.inspectActive && !LastValueWasNull); } // allow IValue for null strings though cell.SubContentButton.Component.gameObject.SetActive(args.subContentButtonActive && (!LastValueWasNull || State == ValueState.String)); }
void AddSuggestion(Type type) { if (suggestedNames.Contains(type.FullName)) { return; } suggestedNames.Add(type.FullName); if (!sharedTypeToLabel.ContainsKey(type.FullName)) { sharedTypeToLabel.Add(type.FullName, SignatureHighlighter.Parse(type, true)); } suggestions.Add(new Suggestion(sharedTypeToLabel[type.FullName], type.FullName)); }
private void SetNormalArgRows() { for (int i = 0; i < arguments.Length || i < argRows.Count; i++) { if (i >= arguments.Length) { if (i >= argRows.Count) { break; } else { // exceeded actual args, but still iterating so there must be views left, disable them argRows[i].SetActive(false); } continue; } var arg = arguments[i]; if (i >= argRows.Count) { AddArgRow(i, false); } argRows[i].SetActive(true); argLabels[i].text = $"{SignatureHighlighter.Parse(arg.ParameterType, false)} <color={SignatureHighlighter.LOCAL_ARG}>{arg.Name}</color>"; if (arg.ParameterType == typeof(string)) { argInputFields[i].PlaceholderText.text = ""; } else { var elemType = arg.ParameterType; if (elemType.IsByRef) { elemType = elemType.GetElementType(); } argInputFields[i].PlaceholderText.text = $"eg. {ParseUtility.GetExampleInput(elemType)}"; } } }
public void SetCell(ButtonCell cell, int index) { if (!cachedCellTexts.ContainsKey(index)) { string text; if (m_context == SearchContext.StaticClass) { text = SignatureHighlighter.Parse(currentResults[index] as Type, true); } else { text = ToStringUtility.ToStringWithType(currentResults[index], currentResults[index]?.GetActualType()); } cachedCellTexts.Add(index, text); } cell.Button.ButtonText.text = cachedCellTexts[index]; }
public void SetKey(object key) { this.DictKey = key; this.DisplayedKey = key.TryCast(); var type = DisplayedKey.GetType(); if (ParseUtility.CanParse(type)) { KeyInputWanted = true; KeyInputText = ParseUtility.ToStringForInput(DisplayedKey, type); KeyInputTypeText = SignatureHighlighter.Parse(type, false); } else { KeyInputWanted = false; InspectWanted = type != typeof(bool) && !type.IsEnum; KeyLabelText = ToStringUtility.ToStringWithType(DisplayedKey, type, true); } }
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); }
// Called from ButtonListHandler.SetCell, will be valid private void SetComponentCell(ComponentCell cell, int index) { var entries = GetEntries(); cell.Enable(); var comp = entries[index]; var type = comp.GetActualType(); if (!compToStringCache.ContainsKey(type.AssemblyQualifiedName)) { compToStringCache.Add(type.AssemblyQualifiedName, SignatureHighlighter.Parse(type, true)); } cell.Button.ButtonText.text = compToStringCache[type.AssemblyQualifiedName]; if (typeof(Behaviour).IsAssignableFrom(type)) { cell.BehaviourToggle.interactable = true; cell.BehaviourToggle.Set(comp.TryCast <Behaviour>().enabled, false); cell.BehaviourToggle.graphic.color = new Color(0.8f, 1, 0.8f, 0.3f); } else { cell.BehaviourToggle.interactable = false; cell.BehaviourToggle.Set(true, false); //RuntimeProvider.Instance.SetColorBlock(cell.BehaviourToggle,) cell.BehaviourToggle.graphic.color = new Color(0.2f, 0.2f, 0.2f); } // if component is the first index it must be the transform, dont show Destroy button for it. if (index == 0 && cell.DestroyButton.Component.gameObject.activeSelf) { cell.DestroyButton.Component.gameObject.SetActive(false); } else if (index > 0 && !cell.DestroyButton.Component.gameObject.activeSelf) { cell.DestroyButton.Component.gameObject.SetActive(true); } }
// 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); }
public void OnBorrowed(EvaluateWidget evaluator, Type genericConstraint) { this.evaluator = evaluator; this.genericType = genericConstraint; typeCompleter.Enabled = true; typeCompleter.BaseType = genericType; typeCompleter.CacheTypes(); var constraints = genericType.GetGenericParameterConstraints(); typeCompleter.GenericConstraints = constraints; var sb = new StringBuilder($"<color={SignatureHighlighter.CONST}>{genericType.Name}</color>"); for (int j = 0; j < constraints.Length; j++) { if (j == 0) { sb.Append(' ').Append('('); } else { sb.Append(',').Append(' '); } sb.Append(SignatureHighlighter.Parse(constraints[j], false)); if (j + 1 == constraints.Length) { sb.Append(')'); } } argNameLabel.text = sb.ToString(); }
public virtual void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member) { this.Owner = inspector; this.NameLabelText = SignatureHighlighter.Parse(member.DeclaringType, false, member); this.NameForFiltering = $"{member.DeclaringType.Name}.{member.Name}"; }
public void OnBorrowed(EvaluateWidget evaluator, ParameterInfo paramInfo) { this.evaluator = evaluator; this.paramInfo = paramInfo; this.paramType = paramInfo.ParameterType; if (paramType.IsByRef) { paramType = paramType.GetElementType(); } this.argNameLabel.text = $"{SignatureHighlighter.Parse(paramType, false)} <color={SignatureHighlighter.LOCAL_ARG}>{paramInfo.Name}</color>"; if (ParseUtility.CanParse(paramType) || typeof(Type).IsAssignableFrom(paramType)) { usingBasicLabel = false; this.inputField.Component.gameObject.SetActive(true); this.basicLabelHolder.SetActive(false); this.typeCompleter.Enabled = typeof(Type).IsAssignableFrom(paramType); this.enumCompleter.Enabled = paramType.IsEnum; this.enumHelperButton.Component.gameObject.SetActive(paramType.IsEnum); if (!typeCompleter.Enabled) { if (paramType == typeof(string)) { inputField.PlaceholderText.text = "..."; } else { inputField.PlaceholderText.text = $"eg. {ParseUtility.GetExampleInput(paramType)}"; } } else { inputField.PlaceholderText.text = "Enter a Type name..."; this.typeCompleter.BaseType = typeof(object); this.typeCompleter.CacheTypes(); } if (enumCompleter.Enabled) { enumCompleter.EnumType = paramType; enumCompleter.CacheEnumValues(); } } else { // non-parsable, and not a Type usingBasicLabel = true; this.inputField.Component.gameObject.SetActive(false); this.basicLabelHolder.SetActive(true); this.typeCompleter.Enabled = false; this.enumCompleter.Enabled = false; this.enumHelperButton.Component.gameObject.SetActive(false); SetDisplayedValueFromPaste(); } }
protected string GetValueLabel() { string label = ""; switch (State) { case ValueState.NotEvaluated: return($"<i>{NOT_YET_EVAL} ({SignatureHighlighter.Parse(FallbackType, true)})</i>"); case ValueState.Exception: return($"<i><color=red>{LastException.ReflectionExToString()}</color></i>"); // bool and number dont want the label for the value at all case ValueState.Boolean: case ValueState.Number: return(null); // and valuestruct also doesnt want it if we can parse it case ValueState.ValueStruct: if (ParseUtility.CanParse(LastValueType)) { return(null); } break; // string wants it trimmed to max 200 chars case ValueState.String: if (!LastValueWasNull) { return($"\"{ToStringUtility.PruneString(Value as string, 200, 5)}\""); } break; // try to prefix the count of the collection for lists and dicts case ValueState.Collection: if (!LastValueWasNull) { if (Value is IList iList) { label = $"[{iList.Count}] "; } else if (Value is ICollection iCol) { label = $"[{iCol.Count}] "; } else { label = "[?] "; } } break; case ValueState.Dictionary: if (!LastValueWasNull) { if (Value is IDictionary iDict) { label = $"[{iDict.Count}] "; } else { label = "[?] "; } } break; } // Cases which dont return will append to ToStringWithType return(label += ToStringUtility.ToStringWithType(Value, FallbackType, true)); }